pydantic_core.core_schema

此模块包含用于构建 pydantic_core 可以验证和序列化的模式的定义。

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

模式配置选项的基类。

属性

名称	类型	描述
title	str	配置的名称。
strict	bool	配置是否应严格遵守指定的规则。
extra_fields_behavior	ExtraBehavior	处理额外字段的行为。
typed_dict_total	bool	TypedDict 是否应被视为 total。默认为 True。
from_attributes	bool	是否对模型、数据类和标签联合键使用属性。
loc_by_alias	bool	是否使用已使用的别名（或“字段必需”错误的第一个别名）而不是 field_names 来构造错误 loc。默认为 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_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 backport。
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。

SerializationInfo

基类：Protocol

context property

context: Any | None

当前序列化上下文。

ValidationInfo

基类：Protocol

传递给验证函数的参数。

context property

context: Any | None

当前验证上下文。

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

返回用于使用自定义类型进行序列化的模式。

参数

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

.venv/lib/python3.12/site-packages/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

返回用于使用函数进行序列化的模式，可以是“通用”函数或“字段”函数。

参数

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

.venv/lib/python3.12/site-packages/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

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

参数

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

.venv/lib/python3.12/site-packages/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 方法进行序列化的模式。

参数

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

.venv/lib/python3.12/site-packages/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__ 方法进行序列化的模式。

参数

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

.venv/lib/python3.12/site-packages/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

返回用于使用模型进行序列化的模式。

参数

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

.venv/lib/python3.12/site-packages/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

返回无效的模式，用于指示模式无效。

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

参数

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

.venv/lib/python3.12/site-packages/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

ComputedFields 是模型或数据类的属性，包含在序列化中。

参数

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

.venv/lib/python3.12/site-packages/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

返回匹配任何值的模式，例如

from pydantic_core import SchemaValidator, core_schema

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

参数

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

.venv/lib/python3.12/site-packages/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 值的模式，例如

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	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回匹配 bool 值的模式，例如

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	coerce	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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)

值应该是 bool 类型还是可以转换为 bool 类型的值

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

int_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

参数

名称	类型	描述	默认值
返回匹配 int 值的模式，例如	multiple_of	int | None	None
值必须是此数字的倍数	multiple_of	le	None
值必须小于或等于此数字	multiple_of	ge	None
值必须大于或等于此数字	multiple_of	lt	None
值必须严格小于此数字	multiple_of	gt	None
strict	bool | None	值必须严格大于此数字	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    )

coerce

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

值应该是 int 类型还是可以转换为 int 类型的值

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	float_schema	None
返回匹配 int 值的模式，例如	返回匹配 float 值的模式，例如	int | None	None
值必须是此数字的倍数	返回匹配 float 值的模式，例如	le	None
值必须小于或等于此数字	返回匹配 float 值的模式，例如	ge	None
值必须大于或等于此数字	返回匹配 float 值的模式，例如	lt	None
值必须严格小于此数字	返回匹配 float 值的模式，例如	gt	None
strict	bool | None	allow_inf_nan	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    )

是否允许 inf 和 nan 值

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

coerce

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	float_schema	None
返回匹配 int 值的模式，例如	float | None	int | None	None
值必须是此数字的倍数	float | None	le	None
值必须小于或等于此数字	float | None	ge	None
值必须大于或等于此数字	float | None	lt	None
值必须严格小于此数字	float | None	gt	None
值应该是 float 类型还是可以转换为 float 类型的值	multiple_of	decimal_schema	None
返回匹配 decimal 值的模式，例如	multiple_of	max_digits	None
strict	bool | None	allow_inf_nan	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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(
    *,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> ComplexSchema

decimal_places

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	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    )

complex_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

返回匹配 complex 值的模式，例如

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'

参数

名称	类型	描述	默认值
coerce	值应该是 complex 对象实例还是可以转换为 complex 对象的值	str_schema	None
返回匹配 string 值的模式，例如	multiple_of	pattern	None
str | Pattern[str] | None	multiple_of	值必须匹配的正则表达式模式	None
max_length	bool | None	值必须最多为此长度	None
min_length	bool | None	值必须至少为此长度	None
strip_whitespace	bool | None	是否去除值的空白	None
regex_engine	to_lower	是否将值转换为小写	None
strict	bool | None	to_upper	None
coerce_numbers_to_str	bool | None	是否启用将任何 Number 类型强制转换为 str (不适用于 strict 模式)。	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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(
    *,
    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

regex_engine

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'

参数

名称	类型	描述	默认值
返回匹配 string 值的模式，例如	multiple_of	pattern	None
str | Pattern[str] | None	multiple_of	值必须匹配的正则表达式模式	None
strict	bool | None	Literal['rust-regex', 'python-re'] | None	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    )

用于模式验证的正则表达式引擎。默认为 'rust-regex'。 - rust-regex 使用 regex Rust crate，它是非回溯的，因此更具 DDoS 抵抗力，但不支持所有正则表达式功能。 - python-re 使用 re 模块，它支持所有正则表达式功能，但可能较慢。

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

coerce

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	值应该是 string 类型还是可以转换为 string 类型的值	None
值必须是此数字的倍数	bytes_schema	返回匹配 bytes 值的模式，例如	None
值必须小于或等于此数字	bytes_schema	coerce	None
值必须大于或等于此数字	bytes_schema	值应该是 bytes 类型还是可以转换为 bytes 类型的值	None
值必须严格小于此数字	bytes_schema	date_schema	None
返回匹配 date 值的模式，例如	coerce	值应该是 date 类型还是可以转换为 date 类型的值	None
le	multiple_of	date | None	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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(
    *,
    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

ge

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	date | None	None
值必须是此数字的倍数	值必须大于或等于此日期	lt	None
值必须小于或等于此数字	值必须大于或等于此日期	date | None	None
值必须大于或等于此数字	值必须大于或等于此日期	值必须严格小于此日期	None
值必须严格小于此数字	值必须大于或等于此日期	gt	None
date | None	值必须严格大于此日期	now_op	None
Literal['past', 'future'] | None	值必须相对于当前日期在过去或未来	now_utc_offset	timedelta | None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    )

值必须相对于具有此 utc 偏移的当前日期在过去或未来

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

time_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	返回匹配 time 值的模式，例如	None
值必须是此数字的倍数	coerce	值应该是 time 类型还是可以转换为 time 类型的值	None
值必须小于或等于此数字	coerce	le	None
值必须大于或等于此数字	coerce	time | None	None
值必须严格小于此数字	coerce	值必须小于或等于此时刻	None
返回匹配 date 值的模式，例如	coerce	ge	None
date | None	值必须严格大于此日期	time | None	None
le	multiple_of	值必须大于或等于此时刻	None
Literal['past', 'future'] | None	值必须相对于当前日期在过去或未来	now_utc_offset	timedelta | None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    )

lt

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

time | None

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	值必须严格小于此时刻	None
值必须是此数字的倍数	gt	time | None	None
值必须小于或等于此数字	gt	值必须严格大于此时刻	None
值必须大于或等于此数字	gt	tz_constraint	None
值必须严格小于此数字	gt	Literal['aware', 'naive'] | int | None	None
Literal['past', 'future'] | None	值必须相对于当前日期在过去或未来	now_utc_offset	timedelta | None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    )

值必须是时区感知的或朴素的，或者是一个 int 来指示所需的时区偏移

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

microseconds_precision

from pydantic_core import SchemaValidator, core_schema

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

参数

名称	类型	描述	默认值
Literal['truncate', 'error']	当秒数超过 6 位或微秒数太大时的行为	'truncate'	required
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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)

datetime_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

返回匹配 datetime 值的模式，例如

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	coerce	值应该是 datetime 类型还是可以转换为 datetime 类型的值	required
le	当秒数超过 6 位或微秒数太大时的行为	datetime | None	required
值必须小于或等于此日期时间	ge	datetime | None	None
值必须大于或等于此日期时间	lt	datetime | None	None
strict	bool | None	值必须严格小于此日期时间	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    )

gt

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

datetime | None

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	coerce	值必须严格大于此日期时间	required
now_op	str | None	Literal['past', 'future'] | None	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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(
    cls: type[Any],
    *,
    cls_repr: str | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> IsInstanceSchema

tz_constraint

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]	Literal['aware', 'naive'] | int | None	required
now_op	str | None	Literal['past', 'future'] | None	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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
    )

值必须是时区感知的或朴素的，或者是一个 int 来指示所需的时区偏移 TODO：尚不支持使用基于日期时间更改偏移量的时区信息

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

now_utc_offset

from pydantic_core import SchemaValidator, core_schema

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

参数

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

.venv/lib/python3.12/site-packages/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)

timedelta | None

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

值必须相对于具有此 utc 偏移的当前日期时间在过去或未来

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]

参数

名称	类型	描述	默认值
timedelta_schema	CoreSchema | None	返回匹配 timedelta 值的模式，例如	None
str | Pattern[str] | None	multiple_of	coerce	None
返回匹配 string 值的模式，例如	multiple_of	值应该是 timedelta 类型还是可以转换为 timedelta 类型的值	None
le	bool | None	timedelta | None	None
strict	bool | None	值必须小于或等于此时间差	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	ge	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    )

timedelta | None

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

值必须大于或等于此时间差

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')

参数

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

.venv/lib/python3.12/site-packages/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

返回一个与给定模式的元组匹配的模式，例如：

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)

参数

名称	类型	描述	默认值
timedelta_schema	CoreSchema | None	值必须是元组，其元素必须与此模式匹配	None
str | Pattern[str] | None	multiple_of	值必须是至少包含这么多元素的元组	None
返回匹配 string 值的模式，例如	multiple_of	值必须是至多包含这么多元素的元组	None
strict	bool | None	值必须是正好包含这么多元素的元组	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	ge	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个与模式元组匹配的模式，带有可选的可变项目，例如：

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)

参数

名称	类型	描述	默认值
timedelta_schema	list[CoreSchema]	值必须是元组，其元素必须与这些模式匹配	required
variadic_item_index	multiple_of	items_schema 中要被视为可变模式的索引（遵循 PEP 646）	None
str | Pattern[str] | None	multiple_of	值必须是至少包含这么多元素的元组	None
返回匹配 string 值的模式，例如	multiple_of	值必须是至多包含这么多元素的元组	None
le	bool | None	timedelta | None	None
strict	bool | None	值必须是正好包含这么多元素的元组	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	ge	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个与给定模式的集合匹配的模式，例如：

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}

参数

名称	类型	描述	默认值
timedelta_schema	CoreSchema | None	值必须是集合，其元素必须与此模式匹配	None
str | Pattern[str] | None	multiple_of	值必须是至少包含这么多元素的集合	None
返回匹配 string 值的模式，例如	multiple_of	值必须是至多包含这么多元素的集合	None
le	bool | None	timedelta | None	None
strict	bool | None	值必须是正好包含这么多元素的集合	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个与给定模式的冻结集合匹配的模式，例如：

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})

参数

名称	类型	描述	默认值
timedelta_schema	CoreSchema | None	值必须是冻结集合，其元素必须与此模式匹配	None
str | Pattern[str] | None	multiple_of	值必须是至少包含这么多元素的冻结集合	None
返回匹配 string 值的模式，例如	multiple_of	值必须是至多包含这么多元素的冻结集合	None
le	bool | None	timedelta | None	None
strict	bool | None	值必须是正好包含这么多元素的冻结集合	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个与生成器值匹配的模式，例如：

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())

与其他类型不同，经过验证的生成器不会急切地引发 ValidationErrors，而是在实际从生成器读取违反规则的值时引发 ValidationError。这是为了确保“经过验证的”生成器保留延迟计算的好处。

参数

名称	类型	描述	默认值
timedelta_schema	CoreSchema | None	值必须是生成器，其元素必须与此模式匹配	None
str | Pattern[str] | None	multiple_of	值必须是生成至少这么多元素的生成器	None
返回匹配 string 值的模式，例如	multiple_of	值必须是生成至多这么多元素的生成器	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	ge	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> DictSchema

返回一个与字典值匹配的模式，例如：

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	值必须是字典，其键必须与此模式匹配	None
values_schema	CoreSchema | None	值必须是字典，其值必须与此模式匹配	None
str | Pattern[str] | None	multiple_of	值必须是至少包含这么多元素的字典	None
返回匹配 string 值的模式，例如	multiple_of	值必须是至多包含这么多元素的字典	None
strict	bool | None	键和值是否应以严格模式进行验证	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    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
        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,
        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

返回一个在验证之前调用验证器函数的模式，不提供 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	要调用的验证器函数	required
schema	CoreSchema	用于验证验证器函数输出的模式	required
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个在验证之前调用验证器函数的模式，该函数在调用时会带有一个 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(), field_name='a'
)
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	要调用的验证器函数	required
field_name	str | None	字段的名称	None
schema	CoreSchema	用于验证验证器函数输出的模式	required
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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(), field_name='a'
    )
    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
        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=_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

返回一个在验证之后调用验证器函数的模式，不提供 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	在模式验证后要调用的验证器函数	required
schema	CoreSchema	在验证器函数之前要验证的模式	required
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个在验证之后调用验证器函数的模式，该函数在调用时会带有一个 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(), field_name='a'
)
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	在模式验证后要调用的验证器函数	required
schema	CoreSchema	在验证器函数之前要验证的模式	required
field_name	str | None	此验证器应用到的字段名称（如果有）	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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(), field_name='a'
    )
    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 validators is applied to, if any
        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='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

返回一个模式，该模式调用一个带有 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	要调用的验证器函数	required
schema	CoreSchema	用于验证验证器函数输出的模式	required
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个模式，该模式调用一个带有 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	要调用的验证器函数	required
schema	CoreSchema	用于验证验证器函数输出的模式	required
field_name	str | None	此验证器应用到的字段名称（如果有）	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心模式	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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 validators is applied to, if any
        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
    """
    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

返回一个使用提供的函数进行验证的模式，不传递 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	要调用的验证器函数	required
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个使用提供的函数进行验证的模式，传递一个 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	要调用的验证器函数	required
field_name	str | None	此验证器应用到的字段名称（如果有）	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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 validators is applied to, if any
        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=_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

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

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	要添加默认值的模式	required
default	coerce	要使用的默认值	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	如果模式验证失败，该怎么做。选项包括 'raise'、'omit'、'default'	None
validate_default	bool | None	是否应验证默认值	None
strict	bool | None	底层模式是否应以严格模式进行验证	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个与可空值匹配的模式，例如：

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	要包装的模式	required
strict	bool | None	底层模式是否应以严格模式进行验证	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个与联合值匹配的模式，例如：

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]]	要匹配的模式。如果是元组，则第二项用作案例的标签。	required
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	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个与标记联合值匹配的模式，例如：

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]	要匹配的模式。当使用鉴别器值从 choices 检索模式时，如果该值为字符串，则应将其反馈到 choices 映射中，直到获得模式为止（此方法是为了防止单个模式在 Rust 中被多次拥有）	required
discriminator	str | list[str | int] | list[list[str | int]] | Callable[[Any], Any]	用于确定要使用的模式的鉴别器 * 如果 discriminator 是字符串，则它是用作鉴别器的属性的名称 * 如果 discriminator 是整数/字符串列表，则应将其用作访问鉴别器的“路径” * 如果 discriminator 是列表的列表，则每个内部列表都是一个路径，并且使用第一个存在的路径 * 如果 discriminator 是可调用对象，则它应在调用要验证的值时返回鉴别器；可调用对象可以返回 None 以指示输入中不存在匹配的鉴别器	required
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	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个链接提供的验证模式的模式，例如：

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]	要链接的模式	required
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个使用宽松或严格模式的模式，例如：

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	要使用的宽松模式	required
strict_schema	CoreSchema	要使用的严格模式	required
strict	bool | None	是否应使用严格模式	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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 模式的模式

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 输入的模式	required
python_schema	CoreSchema	用于 Python 输入的模式	required
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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
) -> TypedDictField

返回一个与类型化字典字段匹配的模式，例如：

from pydantic_core import core_schema

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

参数

名称	类型	描述	默认值
schema	CoreSchema	用于字段的模式	required
required	bool | None	字段是否为必需项，否则使用类型化字典中 total 的值	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	您要包含在模式中的任何其他信息，pydantic-core 不使用	None

.venv/lib/python3.12/site-packages/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,
) -> 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
        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,
        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

返回一个与类型化字典匹配的模式，例如：

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

.venv/lib/python3.12/site-packages/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,
    frozen: bool | None = None,
    metadata: dict[str, Any] | None = None
) -> ModelField

返回模型字段的模式，例如：

from pydantic_core import core_schema

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

参数

名称	类型	描述	默认值
schema	CoreSchema	用于字段的模式	required
validation_alias	str | list[str | int] | list[list[str | int]] | None	用于在验证数据中查找字段的别名	None
serialization_alias	str | None	序列化时用作键的别名	None
serialization_exclude	bool | None	序列化时是否排除该字段	None
frozen	bool | None	字段是否为冻结状态	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None

.venv/lib/python3.12/site-packages/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,
    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
        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,
        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 模型的字段匹配的模式，例如：

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

.venv/lib/python3.12/site-packages/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

模型模式通常包含类型化字典模式。它将运行类型化字典验证器，然后创建一个新类，并将从类型化字典验证器返回的字典和字段集设置为 __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]	用于模型的类	required
schema	CoreSchema	用于模型的模式	required
generic_origin	type[Any] | None	用于此模型的原始类型，如果它是参数化的泛型。例如，如果此模型模式表示 SomeModel[int]，则 generic_origin 为 SomeModel	None
custom_init	bool | None	模型是否具有自定义 init 方法	None
root_model	bool | None	模型是否为 RootModel	None
post_init	str | None	用于模型的 init 之后的调用	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	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    frozen: bool | None = None
) -> DataclassField

返回数据类字段的模式，例如：

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	用于参数参数的名称	required
schema	CoreSchema	用于参数参数的模式	required
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
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
frozen	bool | None	字段是否为冻结状态	None

.venv/lib/python3.12/site-packages/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,
    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
        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,
        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

返回用于验证数据类参数的模式，例如：

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	正在验证的数据类的名称	required
fields	list[DataclassField]	用于数据类的字段	required
computed_fields	list[ComputedField] | None	序列化数据类时要使用的计算字段	None
collect_init_only	bool | None	是否将仅限初始化的字段收集到字典中以传递给 __post_init__	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None
extra_behavior	ExtraBehavior | None	如何处理额外的字段	None

.venv/lib/python3.12/site-packages/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

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

参数

名称	类型	描述	默认值
cls	type[Any]	数据类类型，用于执行子类检查	required
schema	CoreSchema	用于数据类字段的模式	required
fields	list[str]	数据类的字段，这用于序列化以及重新验证期间和验证赋值时的验证	required
generic_origin	type[Any] | None	用于此数据类的原始类型，如果它是参数化的泛型。例如，如果此模型模式表示 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	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None
frozen	bool | None	数据类是否为冻结状态	None
slots	bool | None	数据类上是否 slots=True，表示每个字段都是独立分配的，而不是简单地设置 __dict__，默认为 false	None

.venv/lib/python3.12/site-packages/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

返回与参数参数匹配的模式，例如：

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	用于参数参数的名称	required
schema	CoreSchema	用于参数参数的模式	required
mode	Literal['positional_only', 'positional_or_keyword', 'keyword_only'] | None	用于参数参数的模式	None
alias	str | list[str | int] | list[list[str | int]] | None	用于参数参数的别名	None

.venv/lib/python3.12/site-packages/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

返回与参数模式匹配的模式，例如：

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

.venv/lib/python3.12/site-packages/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

返回与参数参数匹配的模式，例如：

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	用于参数参数的名称	required
schema	CoreSchema	用于参数参数的模式	required
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

.venv/lib/python3.12/site-packages/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

返回与参数模式匹配的模式，例如：

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})

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

参数

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

.venv/lib/python3.12/site-packages/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

返回一个与参数模式匹配的模式，然后调用一个函数，例如：

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	用于参数模式的参数	required
function	Callable[..., Any]	用于调用模式的函数	required
function_name	str | None	用于调用模式的函数名称，如果未提供，则使用 function.__name__	None
return_schema	CoreSchema | None	用于调用模式的返回模式	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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

返回一个与自定义错误值匹配的模式，例如：

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	用于自定义错误模式的模式	required
custom_error_type	str	用于自定义错误模式的自定义错误类型	required
custom_error_message	str | None	用于自定义错误模式的自定义错误消息	None
custom_error_context	dict[str, Any] | None	用于自定义错误模式的自定义错误上下文	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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 值匹配的模式，例如：

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 模式的模式	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> UrlSchema

返回一个与 URL 值匹配的模式，例如：

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/

参数

名称	类型	描述	默认值
返回匹配 string 值的模式，例如	multiple_of	URL 的最大长度	None
allowed_schemes	list[str] | None	允许的 URL 方案	None
host_required	bool | None	URL 是否必须具有主机	None
default_host	str | None	如果 URL 没有主机，则使用的默认主机	None
default_port	multiple_of	如果 URL 没有端口，则使用的默认端口	None
default_path	str | None	如果 URL 没有路径，则使用的默认路径	None
strict	bool | None	是否使用严格的 URL 解析	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    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
        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,
        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,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> MultiHostUrlSchema

返回一个与可能具有多个主机的 URL 值匹配的模式，例如：

from pydantic_core import SchemaValidator, core_schema

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

参数

名称	类型	描述	默认值
返回匹配 string 值的模式，例如	multiple_of	URL 的最大长度	None
allowed_schemes	list[str] | None	允许的 URL 方案	None
host_required	bool | None	URL 是否必须具有主机	None
default_host	str | None	如果 URL 没有主机，则使用的默认主机	None
default_port	multiple_of	如果 URL 没有端口，则使用的默认端口	None
default_path	str | None	如果 URL 没有路径，则使用的默认路径	None
strict	bool | None	是否使用严格的 URL 解析	None
ref	str | None	模式的可选唯一标识符，用于在其他地方引用该模式	None
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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,
    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://127.0.0.1,0.0.0.0,127.0.0.1'))
    #> redis://127.0.0.1,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
        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,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

definitions_schema

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

构建一个包含内部模式和定义列表的模式，这些定义可以在内部模式中使用。

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	内部模式	required
definitions	list[CoreSchema]	可以在内部模式中引用的定义列表	required

.venv/lib/python3.12/site-packages/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”中的模式的模式，这对于嵌套的递归模型以及当您想要将验证器与主模式分开定义时非常有用，例如：

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	用于定义引用模式的模式引用	required
metadata	dict[str, Any] | None	您要包含在模式中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化模式	None

.venv/lib/python3.12/site-packages/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
    )