Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/pydantic_core/core

1"""

2This module contains definitions to build schemas which `pydantic_core` can

3validate and serialize.

4"""

6from __future__ import annotations as _annotations

8import sys

9import warnings

10from collections.abc import Hashable, Mapping

11from datetime import date, datetime, time, timedelta

12from decimal import Decimal

13from re import Pattern

14from typing import TYPE_CHECKING, Any, Callable, Literal, Union

16from typing_extensions import TypeVar, deprecated

18if sys.version_info < (3, 12):

19 from typing_extensions import TypedDict

20else:

21 from typing import TypedDict

23if sys.version_info < (3, 11):

24 from typing_extensions import Protocol, Required, TypeAlias

25else:

26 from typing import Protocol, Required, TypeAlias

28if TYPE_CHECKING:

29 from pydantic_core import PydanticUndefined

30else:

31 # The initial build of pydantic_core requires PydanticUndefined to generate

32 # the core schema; so we need to conditionally skip it. mypy doesn't like

33 # this at all, hence the TYPE_CHECKING branch above.

34 try:

35 from pydantic_core import PydanticUndefined

36 except ImportError:

37 PydanticUndefined = object()

40ExtraBehavior = Literal['allow', 'forbid', 'ignore']

43class CoreConfig(TypedDict, total=False):

44 """

45 Base class for schema configuration options.

47 Attributes:

48 title: The name of the configuration.

49 strict: Whether the configuration should strictly adhere to specified rules.

50 extra_fields_behavior: The behavior for handling extra fields.

51 typed_dict_total: Whether the TypedDict should be considered total. Default is `True`.

52 from_attributes: Whether to use attributes for models, dataclasses, and tagged union keys.

53 loc_by_alias: Whether to use the used alias (or first alias for "field required" errors) instead of

54 `field_names` to construct error `loc`s. Default is `True`.

55 revalidate_instances: Whether instances of models and dataclasses should re-validate. Default is 'never'.

56 validate_default: Whether to validate default values during validation. Default is `False`.

57 str_max_length: The maximum length for string fields.

58 str_min_length: The minimum length for string fields.

59 str_strip_whitespace: Whether to strip whitespace from string fields.

60 str_to_lower: Whether to convert string fields to lowercase.

61 str_to_upper: Whether to convert string fields to uppercase.

62 allow_inf_nan: Whether to allow infinity and NaN values for float fields. Default is `True`.

63 ser_json_timedelta: The serialization option for `timedelta` values. Default is 'iso8601'.

64 Note that if ser_json_temporal is set, then this param will be ignored.

65 ser_json_temporal: The serialization option for datetime like values. Default is 'iso8601'.

66 The types this covers are datetime, date, time and timedelta.

67 If this is set, it will take precedence over ser_json_timedelta

68 ser_json_bytes: The serialization option for `bytes` values. Default is 'utf8'.

69 ser_json_inf_nan: The serialization option for infinity and NaN values

70 in float fields. Default is 'null'.

71 val_json_bytes: The validation option for `bytes` values, complementing ser_json_bytes. Default is 'utf8'.

72 hide_input_in_errors: Whether to hide input data from `ValidationError` representation.

73 validation_error_cause: Whether to add user-python excs to the __cause__ of a ValidationError.

74 Requires exceptiongroup backport pre Python 3.11.

75 coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode).

76 regex_engine: The regex engine to use for regex pattern validation. Default is 'rust-regex'. See `StringSchema`.

77 cache_strings: Whether to cache strings. Default is `True`, `True` or `'all'` is required to cache strings

78 during general validation since validators don't know if they're in a key or a value.

79 validate_by_alias: Whether to use the field's alias when validating against the provided input data. Default is `True`.

80 validate_by_name: Whether to use the field's name when validating against the provided input data. Default is `False`. Replacement for `populate_by_name`.

81 serialize_by_alias: Whether to serialize by alias. Default is `False`, expected to change to `True` in V3.

82 url_preserve_empty_path: Whether to preserve empty URL paths when validating values for a URL type. Defaults to `False`.

83 """

85 title: str

86 strict: bool

87 # settings related to typed dicts, model fields, dataclass fields

88 extra_fields_behavior: ExtraBehavior

89 typed_dict_total: bool # default: True

90 # used for models, dataclasses, and tagged union keys

91 from_attributes: bool

92 # whether to use the used alias (or first alias for "field required" errors) instead of field_names

93 # to construct error `loc`s, default True

94 loc_by_alias: bool

95 # whether instances of models and dataclasses (including subclass instances) should re-validate, default 'never'

96 revalidate_instances: Literal['always', 'never', 'subclass-instances']

97 # whether to validate default values during validation, default False

98 validate_default: bool

99 # used on typed-dicts and arguments

100 # fields related to string fields only

101 str_max_length: int

102 str_min_length: int

103 str_strip_whitespace: bool

104 str_to_lower: bool

105 str_to_upper: bool

106 # fields related to float fields only

107 allow_inf_nan: bool # default: True

108 # the config options are used to customise serialization to JSON

109 ser_json_timedelta: Literal['iso8601', 'float'] # default: 'iso8601'

110 ser_json_temporal: Literal['iso8601', 'seconds', 'milliseconds'] # default: 'iso8601'

111 ser_json_bytes: Literal['utf8', 'base64', 'hex'] # default: 'utf8'

112 ser_json_inf_nan: Literal['null', 'constants', 'strings'] # default: 'null'

113 val_json_bytes: Literal['utf8', 'base64', 'hex'] # default: 'utf8'

114 # used to hide input data from ValidationError repr

115 hide_input_in_errors: bool

116 validation_error_cause: bool # default: False

117 coerce_numbers_to_str: bool # default: False

118 regex_engine: Literal['rust-regex', 'python-re'] # default: 'rust-regex'

119 cache_strings: Union[bool, Literal['all', 'keys', 'none']] # default: 'True'

120 validate_by_alias: bool # default: True

121 validate_by_name: bool # default: False

122 serialize_by_alias: bool # default: False

123 url_preserve_empty_path: bool # default: False

124

125

126IncExCall: TypeAlias = 'set[int | str] | dict[int | str, IncExCall] | None'

127

128ContextT = TypeVar('ContextT', covariant=True, default='Any | None')

129

130

131class SerializationInfo(Protocol[ContextT]):

132 """Extra data used during serialization."""

133

134 @property

135 def include(self) -> IncExCall:

136 """The `include` argument set during serialization."""

137 ...

138

139 @property

140 def exclude(self) -> IncExCall:

141 """The `exclude` argument set during serialization."""

142 ...

143

144 @property

145 def context(self) -> ContextT:

146 """The current serialization context."""

147 ...

148

149 @property

150 def mode(self) -> Literal['python', 'json'] | str:

151 """The serialization mode set during serialization."""

152 ...

153

154 @property

155 def by_alias(self) -> bool:

156 """The `by_alias` argument set during serialization."""

157 ...

158

159 @property

160 def exclude_unset(self) -> bool:

161 """The `exclude_unset` argument set during serialization."""

162 ...

163

164 @property

165 def exclude_defaults(self) -> bool:

166 """The `exclude_defaults` argument set during serialization."""

167 ...

168

169 @property

170 def exclude_none(self) -> bool:

171 """The `exclude_none` argument set during serialization."""

172 ...

173

174 @property

175 def exclude_computed_fields(self) -> bool:

176 """The `exclude_computed_fields` argument set during serialization."""

177 ...

178

179 @property

180 def serialize_as_any(self) -> bool:

181 """The `serialize_as_any` argument set during serialization."""

182 ...

183

184 @property

185 def round_trip(self) -> bool:

186 """The `round_trip` argument set during serialization."""

187 ...

188

189 def mode_is_json(self) -> bool: ...

190

191 def __str__(self) -> str: ...

192

193 def __repr__(self) -> str: ...

194

195

196class FieldSerializationInfo(SerializationInfo[ContextT], Protocol):

197 """Extra data used during field serialization."""

198

199 @property

200 def field_name(self) -> str:

201 """The name of the current field being serialized."""

202 ...

203

204

205class ValidationInfo(Protocol[ContextT]):

206 """Extra data used during validation."""

207

208 @property

209 def context(self) -> ContextT:

210 """The current validation context."""

211 ...

212

213 @property

214 def config(self) -> CoreConfig | None:

215 """The CoreConfig that applies to this validation."""

216 ...

217

218 @property

219 def mode(self) -> Literal['python', 'json']:

220 """The type of input data we are currently validating."""

221 ...

222

223 @property

224 def data(self) -> dict[str, Any]:

225 """The data being validated for this model."""

226 ...

227

228 @property

229 def field_name(self) -> str | None:

230 """

231 The name of the current field being validated if this validator is

232 attached to a model field.

233 """

234 ...

235

236

237ExpectedSerializationTypes = Literal[

238 'none',

239 'int',

240 'bool',

241 'float',

242 'str',

243 'bytes',

244 'bytearray',

245 'list',

246 'tuple',

247 'set',

248 'frozenset',

249 'generator',

250 'dict',

251 'datetime',

252 'date',

253 'time',

254 'timedelta',

255 'url',

256 'multi-host-url',

257 'json',

258 'uuid',

259 'any',

260]

261

262

263class SimpleSerSchema(TypedDict, total=False):

264 type: Required[ExpectedSerializationTypes]

265

266

267def simple_ser_schema(type: ExpectedSerializationTypes) -> SimpleSerSchema:

268 """

269 Returns a schema for serialization with a custom type.

270

271 Args:

272 type: The type to use for serialization

273 """

274 return SimpleSerSchema(type=type)

275

276

277# (input_value: Any, /) -> Any

278GeneralPlainNoInfoSerializerFunction = Callable[[Any], Any]

279# (input_value: Any, info: FieldSerializationInfo, /) -> Any

280GeneralPlainInfoSerializerFunction = Callable[[Any, SerializationInfo[Any]], Any]

281# (model: Any, input_value: Any, /) -> Any

282FieldPlainNoInfoSerializerFunction = Callable[[Any, Any], Any]

283# (model: Any, input_value: Any, info: FieldSerializationInfo, /) -> Any

284FieldPlainInfoSerializerFunction = Callable[[Any, Any, FieldSerializationInfo[Any]], Any]

285SerializerFunction = Union[

286 GeneralPlainNoInfoSerializerFunction,

287 GeneralPlainInfoSerializerFunction,

288 FieldPlainNoInfoSerializerFunction,

289 FieldPlainInfoSerializerFunction,

290]

291

292WhenUsed = Literal['always', 'unless-none', 'json', 'json-unless-none']

293"""

294Values have the following meanings:

295

296* `'always'` means always use

297* `'unless-none'` means use unless the value is `None`

298* `'json'` means use when serializing to JSON

299* `'json-unless-none'` means use when serializing to JSON and the value is not `None`

300"""

301

302

303class PlainSerializerFunctionSerSchema(TypedDict, total=False):

304 type: Required[Literal['function-plain']]

305 function: Required[SerializerFunction]

306 is_field_serializer: bool # default False

307 info_arg: bool # default False

308 return_schema: CoreSchema # if omitted, AnySchema is used

309 when_used: WhenUsed # default: 'always'

310

311

312def plain_serializer_function_ser_schema(

313 function: SerializerFunction,

314 *,

315 is_field_serializer: bool | None = None,

316 info_arg: bool | None = None,

317 return_schema: CoreSchema | None = None,

318 when_used: WhenUsed = 'always',

319) -> PlainSerializerFunctionSerSchema:

320 """

321 Returns a schema for serialization with a function, can be either a "general" or "field" function.

322

323 Args:

324 function: The function to use for serialization

325 is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument,

326 and `info` includes `field_name`

327 info_arg: Whether the function takes an `info` argument

328 return_schema: Schema to use for serializing return value

329 when_used: When the function should be called

330 """

331 if when_used == 'always':

332 # just to avoid extra elements in schema, and to use the actual default defined in rust

333 when_used = None # type: ignore

334 return _dict_not_none(

335 type='function-plain',

336 function=function,

337 is_field_serializer=is_field_serializer,

338 info_arg=info_arg,

339 return_schema=return_schema,

340 when_used=when_used,

341 )

342

343

344class SerializerFunctionWrapHandler(Protocol): # pragma: no cover

345 def __call__(self, input_value: Any, index_key: int | str | None = None, /) -> Any: ...

346

347

348# (input_value: Any, serializer: SerializerFunctionWrapHandler, /) -> Any

349GeneralWrapNoInfoSerializerFunction = Callable[[Any, SerializerFunctionWrapHandler], Any]

350# (input_value: Any, serializer: SerializerFunctionWrapHandler, info: SerializationInfo, /) -> Any

351GeneralWrapInfoSerializerFunction = Callable[[Any, SerializerFunctionWrapHandler, SerializationInfo[Any]], Any]

352# (model: Any, input_value: Any, serializer: SerializerFunctionWrapHandler, /) -> Any

353FieldWrapNoInfoSerializerFunction = Callable[[Any, Any, SerializerFunctionWrapHandler], Any]

354# (model: Any, input_value: Any, serializer: SerializerFunctionWrapHandler, info: FieldSerializationInfo, /) -> Any

355FieldWrapInfoSerializerFunction = Callable[[Any, Any, SerializerFunctionWrapHandler, FieldSerializationInfo[Any]], Any]

356WrapSerializerFunction = Union[

357 GeneralWrapNoInfoSerializerFunction,

358 GeneralWrapInfoSerializerFunction,

359 FieldWrapNoInfoSerializerFunction,

360 FieldWrapInfoSerializerFunction,

361]

362

363

364class WrapSerializerFunctionSerSchema(TypedDict, total=False):

365 type: Required[Literal['function-wrap']]

366 function: Required[WrapSerializerFunction]

367 is_field_serializer: bool # default False

368 info_arg: bool # default False

369 schema: CoreSchema # if omitted, the schema on which this serializer is defined is used

370 return_schema: CoreSchema # if omitted, AnySchema is used

371 when_used: WhenUsed # default: 'always'

372

373

374def wrap_serializer_function_ser_schema(

375 function: WrapSerializerFunction,

376 *,

377 is_field_serializer: bool | None = None,

378 info_arg: bool | None = None,

379 schema: CoreSchema | None = None,

380 return_schema: CoreSchema | None = None,

381 when_used: WhenUsed = 'always',

382) -> WrapSerializerFunctionSerSchema:

383 """

384 Returns a schema for serialization with a wrap function, can be either a "general" or "field" function.

385

386 Args:

387 function: The function to use for serialization

388 is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument,

389 and `info` includes `field_name`

390 info_arg: Whether the function takes an `info` argument

391 schema: The schema to use for the inner serialization

392 return_schema: Schema to use for serializing return value

393 when_used: When the function should be called

394 """

395 if when_used == 'always':

396 # just to avoid extra elements in schema, and to use the actual default defined in rust

397 when_used = None # type: ignore

398 return _dict_not_none(

399 type='function-wrap',

400 function=function,

401 is_field_serializer=is_field_serializer,

402 info_arg=info_arg,

403 schema=schema,

404 return_schema=return_schema,

405 when_used=when_used,

406 )

407

408

409class FormatSerSchema(TypedDict, total=False):

410 type: Required[Literal['format']]

411 formatting_string: Required[str]

412 when_used: WhenUsed # default: 'json-unless-none'

413

414

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

416 """

417 Returns a schema for serialization using python's `format` method.

418

419 Args:

420 formatting_string: String defining the format to use

421 when_used: Same meaning as for [general_function_plain_ser_schema], but with a different default

422 """

423 if when_used == 'json-unless-none':

424 # just to avoid extra elements in schema, and to use the actual default defined in rust

425 when_used = None # type: ignore

426 return _dict_not_none(type='format', formatting_string=formatting_string, when_used=when_used)

427

428

429class ToStringSerSchema(TypedDict, total=False):

430 type: Required[Literal['to-string']]

431 when_used: WhenUsed # default: 'json-unless-none'

432

433

434def to_string_ser_schema(*, when_used: WhenUsed = 'json-unless-none') -> ToStringSerSchema:

435 """

436 Returns a schema for serialization using python's `str()` / `__str__` method.

437

438 Args:

439 when_used: Same meaning as for [general_function_plain_ser_schema], but with a different default

440 """

441 s = dict(type='to-string')

442 if when_used != 'json-unless-none':

443 # just to avoid extra elements in schema, and to use the actual default defined in rust

444 s['when_used'] = when_used

445 return s # type: ignore

446

447

448class ModelSerSchema(TypedDict, total=False):

449 type: Required[Literal['model']]

450 cls: Required[type[Any]]

451 schema: Required[CoreSchema]

452

453

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

455 """

456 Returns a schema for serialization using a model.

457

458 Args:

459 cls: The expected class type, used to generate warnings if the wrong type is passed

460 schema: Internal schema to use to serialize the model dict

461 """

462 return ModelSerSchema(type='model', cls=cls, schema=schema)

463

464

465SerSchema = Union[

466 SimpleSerSchema,

467 PlainSerializerFunctionSerSchema,

468 WrapSerializerFunctionSerSchema,

469 FormatSerSchema,

470 ToStringSerSchema,

471 ModelSerSchema,

472]

473

474

475class InvalidSchema(TypedDict, total=False):

476 type: Required[Literal['invalid']]

477 ref: str

478 metadata: dict[str, Any]

479 # note, we never plan to use this, but include it for type checking purposes to match

480 # all other CoreSchema union members

481 serialization: SerSchema

482

483

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

485 """

486 Returns an invalid schema, used to indicate that a schema is invalid.

487

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

489

490 Args:

491 ref: optional unique identifier of the schema, used to reference the schema in other places

492 metadata: Any other information you want to include with the schema, not used by pydantic-core

493 """

494

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

496

497

498class ComputedField(TypedDict, total=False):

499 type: Required[Literal['computed-field']]

500 property_name: Required[str]

501 return_schema: Required[CoreSchema]

502 alias: str

503 metadata: dict[str, Any]

504

505

506def computed_field(

507 property_name: str, return_schema: CoreSchema, *, alias: str | None = None, metadata: dict[str, Any] | None = None

508) -> ComputedField:

509 """

510 ComputedFields are properties of a model or dataclass that are included in serialization.

511

512 Args:

513 property_name: The name of the property on the model or dataclass

514 return_schema: The schema used for the type returned by the computed field

515 alias: The name to use in the serialized output

516 metadata: Any other information you want to include with the schema, not used by pydantic-core

517 """

518 return _dict_not_none(

519 type='computed-field', property_name=property_name, return_schema=return_schema, alias=alias, metadata=metadata

520 )

521

522

523class AnySchema(TypedDict, total=False):

524 type: Required[Literal['any']]

525 ref: str

526 metadata: dict[str, Any]

527 serialization: SerSchema

528

529

530def any_schema(

531 *, ref: str | None = None, metadata: dict[str, Any] | None = None, serialization: SerSchema | None = None

532) -> AnySchema:

533 """

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

535

536 ```py

537 from pydantic_core import SchemaValidator, core_schema

538

539 schema = core_schema.any_schema()

540 v = SchemaValidator(schema)

541 assert v.validate_python(1) == 1

542 ```

543

544 Args:

545 ref: optional unique identifier of the schema, used to reference the schema in other places

546 metadata: Any other information you want to include with the schema, not used by pydantic-core

547 serialization: Custom serialization schema

548 """

549 return _dict_not_none(type='any', ref=ref, metadata=metadata, serialization=serialization)

550

551

552class NoneSchema(TypedDict, total=False):

553 type: Required[Literal['none']]

554 ref: str

555 metadata: dict[str, Any]

556 serialization: SerSchema

557

558

559def none_schema(

560 *, ref: str | None = None, metadata: dict[str, Any] | None = None, serialization: SerSchema | None = None

561) -> NoneSchema:

562 """

563 Returns a schema that matches a None value, e.g.:

564

565 ```py

566 from pydantic_core import SchemaValidator, core_schema

567

568 schema = core_schema.none_schema()

569 v = SchemaValidator(schema)

570 assert v.validate_python(None) is None

571 ```

572

573 Args:

574 ref: optional unique identifier of the schema, used to reference the schema in other places

575 metadata: Any other information you want to include with the schema, not used by pydantic-core

576 serialization: Custom serialization schema

577 """

578 return _dict_not_none(type='none', ref=ref, metadata=metadata, serialization=serialization)

579

580

581class BoolSchema(TypedDict, total=False):

582 type: Required[Literal['bool']]

583 strict: bool

584 ref: str

585 metadata: dict[str, Any]

586 serialization: SerSchema

587

588

589def bool_schema(

590 strict: bool | None = None,

591 ref: str | None = None,

592 metadata: dict[str, Any] | None = None,

593 serialization: SerSchema | None = None,

594) -> BoolSchema:

595 """

596 Returns a schema that matches a bool value, e.g.:

597

598 ```py

599 from pydantic_core import SchemaValidator, core_schema

600

601 schema = core_schema.bool_schema()

602 v = SchemaValidator(schema)

603 assert v.validate_python('True') is True

604 ```

605

606 Args:

607 strict: Whether the value should be a bool or a value that can be converted to a bool

608 ref: optional unique identifier of the schema, used to reference the schema in other places

609 metadata: Any other information you want to include with the schema, not used by pydantic-core

610 serialization: Custom serialization schema

611 """

612 return _dict_not_none(type='bool', strict=strict, ref=ref, metadata=metadata, serialization=serialization)

613

614

615class IntSchema(TypedDict, total=False):

616 type: Required[Literal['int']]

617 multiple_of: int

618 le: int

619 ge: int

620 lt: int

621 gt: int

622 strict: bool

623 ref: str

624 metadata: dict[str, Any]

625 serialization: SerSchema

626

627

628def int_schema(

629 *,

630 multiple_of: int | None = None,

631 le: int | None = None,

632 ge: int | None = None,

633 lt: int | None = None,

634 gt: int | None = None,

635 strict: bool | None = None,

636 ref: str | None = None,

637 metadata: dict[str, Any] | None = None,

638 serialization: SerSchema | None = None,

639) -> IntSchema:

640 """

641 Returns a schema that matches a int value, e.g.:

642

643 ```py

644 from pydantic_core import SchemaValidator, core_schema

645

646 schema = core_schema.int_schema(multiple_of=2, le=6, ge=2)

647 v = SchemaValidator(schema)

648 assert v.validate_python('4') == 4

649 ```

650

651 Args:

652 multiple_of: The value must be a multiple of this number

653 le: The value must be less than or equal to this number

654 ge: The value must be greater than or equal to this number

655 lt: The value must be strictly less than this number

656 gt: The value must be strictly greater than this number

657 strict: Whether the value should be a int or a value that can be converted to a int

658 ref: optional unique identifier of the schema, used to reference the schema in other places

659 metadata: Any other information you want to include with the schema, not used by pydantic-core

660 serialization: Custom serialization schema

661 """

662 return _dict_not_none(

663 type='int',

664 multiple_of=multiple_of,

665 le=le,

666 ge=ge,

667 lt=lt,

668 gt=gt,

669 strict=strict,

670 ref=ref,

671 metadata=metadata,

672 serialization=serialization,

673 )

674

675

676class FloatSchema(TypedDict, total=False):

677 type: Required[Literal['float']]

678 allow_inf_nan: bool # whether 'NaN', '+inf', '-inf' should be forbidden. default: True

679 multiple_of: float

680 le: float

681 ge: float

682 lt: float

683 gt: float

684 strict: bool

685 ref: str

686 metadata: dict[str, Any]

687 serialization: SerSchema

688

689

690def float_schema(

691 *,

692 allow_inf_nan: bool | None = None,

693 multiple_of: float | None = None,

694 le: float | None = None,

695 ge: float | None = None,

696 lt: float | None = None,

697 gt: float | None = None,

698 strict: bool | None = None,

699 ref: str | None = None,

700 metadata: dict[str, Any] | None = None,

701 serialization: SerSchema | None = None,

702) -> FloatSchema:

703 """

704 Returns a schema that matches a float value, e.g.:

705

706 ```py

707 from pydantic_core import SchemaValidator, core_schema

708

709 schema = core_schema.float_schema(le=0.8, ge=0.2)

710 v = SchemaValidator(schema)

711 assert v.validate_python('0.5') == 0.5

712 ```

713

714 Args:

715 allow_inf_nan: Whether to allow inf and nan values

716 multiple_of: The value must be a multiple of this number

717 le: The value must be less than or equal to this number

718 ge: The value must be greater than or equal to this number

719 lt: The value must be strictly less than this number

720 gt: The value must be strictly greater than this number

721 strict: Whether the value should be a float or a value that can be converted to a float

722 ref: optional unique identifier of the schema, used to reference the schema in other places

723 metadata: Any other information you want to include with the schema, not used by pydantic-core

724 serialization: Custom serialization schema

725 """

726 return _dict_not_none(

727 type='float',

728 allow_inf_nan=allow_inf_nan,

729 multiple_of=multiple_of,

730 le=le,

731 ge=ge,

732 lt=lt,

733 gt=gt,

734 strict=strict,

735 ref=ref,

736 metadata=metadata,

737 serialization=serialization,

738 )

739

740

741class DecimalSchema(TypedDict, total=False):

742 type: Required[Literal['decimal']]

743 allow_inf_nan: bool # whether 'NaN', '+inf', '-inf' should be forbidden. default: False

744 multiple_of: Decimal

745 le: Decimal

746 ge: Decimal

747 lt: Decimal

748 gt: Decimal

749 max_digits: int

750 decimal_places: int

751 strict: bool

752 ref: str

753 metadata: dict[str, Any]

754 serialization: SerSchema

755

756

757def decimal_schema(

758 *,

759 allow_inf_nan: bool | None = None,

760 multiple_of: Decimal | None = None,

761 le: Decimal | None = None,

762 ge: Decimal | None = None,

763 lt: Decimal | None = None,

764 gt: Decimal | None = None,

765 max_digits: int | None = None,

766 decimal_places: int | None = None,

767 strict: bool | None = None,

768 ref: str | None = None,

769 metadata: dict[str, Any] | None = None,

770 serialization: SerSchema | None = None,

771) -> DecimalSchema:

772 """

773 Returns a schema that matches a decimal value, e.g.:

774

775 ```py

776 from decimal import Decimal

777 from pydantic_core import SchemaValidator, core_schema

778

779 schema = core_schema.decimal_schema(le=0.8, ge=0.2)

780 v = SchemaValidator(schema)

781 assert v.validate_python('0.5') == Decimal('0.5')

782 ```

783

784 Args:

785 allow_inf_nan: Whether to allow inf and nan values

786 multiple_of: The value must be a multiple of this number

787 le: The value must be less than or equal to this number

788 ge: The value must be greater than or equal to this number

789 lt: The value must be strictly less than this number

790 gt: The value must be strictly greater than this number

791 max_digits: The maximum number of decimal digits allowed

792 decimal_places: The maximum number of decimal places allowed

793 strict: Whether the value should be a float or a value that can be converted to a float

794 ref: optional unique identifier of the schema, used to reference the schema in other places

795 metadata: Any other information you want to include with the schema, not used by pydantic-core

796 serialization: Custom serialization schema

797 """

798 return _dict_not_none(

799 type='decimal',

800 gt=gt,

801 ge=ge,

802 lt=lt,

803 le=le,

804 max_digits=max_digits,

805 decimal_places=decimal_places,

806 multiple_of=multiple_of,

807 allow_inf_nan=allow_inf_nan,

808 strict=strict,

809 ref=ref,

810 metadata=metadata,

811 serialization=serialization,

812 )

813

814

815class ComplexSchema(TypedDict, total=False):

816 type: Required[Literal['complex']]

817 strict: bool

818 ref: str

819 metadata: dict[str, Any]

820 serialization: SerSchema

821

822

823def complex_schema(

824 *,

825 strict: bool | None = None,

826 ref: str | None = None,

827 metadata: dict[str, Any] | None = None,

828 serialization: SerSchema | None = None,

829) -> ComplexSchema:

830 """

831 Returns a schema that matches a complex value, e.g.:

832

833 ```py

834 from pydantic_core import SchemaValidator, core_schema

835

836 schema = core_schema.complex_schema()

837 v = SchemaValidator(schema)

838 assert v.validate_python('1+2j') == complex(1, 2)

839 assert v.validate_python(complex(1, 2)) == complex(1, 2)

840 ```

841

842 Args:

843 strict: Whether the value should be a complex object instance or a value that can be converted to a complex object

844 ref: optional unique identifier of the schema, used to reference the schema in other places

845 metadata: Any other information you want to include with the schema, not used by pydantic-core

846 serialization: Custom serialization schema

847 """

848 return _dict_not_none(

849 type='complex',

850 strict=strict,

851 ref=ref,

852 metadata=metadata,

853 serialization=serialization,

854 )

855

856

857class StringSchema(TypedDict, total=False):

858 type: Required[Literal['str']]

859 pattern: Union[str, Pattern[str]]

860 max_length: int

861 min_length: int

862 strip_whitespace: bool

863 to_lower: bool

864 to_upper: bool

865 regex_engine: Literal['rust-regex', 'python-re'] # default: 'rust-regex'

866 strict: bool

867 coerce_numbers_to_str: bool

868 ref: str

869 metadata: dict[str, Any]

870 serialization: SerSchema

871

872

873def str_schema(

874 *,

875 pattern: str | Pattern[str] | None = None,

876 max_length: int | None = None,

877 min_length: int | None = None,

878 strip_whitespace: bool | None = None,

879 to_lower: bool | None = None,

880 to_upper: bool | None = None,

881 regex_engine: Literal['rust-regex', 'python-re'] | None = None,

882 strict: bool | None = None,

883 coerce_numbers_to_str: bool | None = None,

884 ref: str | None = None,

885 metadata: dict[str, Any] | None = None,

886 serialization: SerSchema | None = None,

887) -> StringSchema:

888 """

889 Returns a schema that matches a string value, e.g.:

890

891 ```py

892 from pydantic_core import SchemaValidator, core_schema

893

894 schema = core_schema.str_schema(max_length=10, min_length=2)

895 v = SchemaValidator(schema)

896 assert v.validate_python('hello') == 'hello'

897 ```

898

899 Args:

900 pattern: A regex pattern that the value must match

901 max_length: The value must be at most this length

902 min_length: The value must be at least this length

903 strip_whitespace: Whether to strip whitespace from the value

904 to_lower: Whether to convert the value to lowercase

905 to_upper: Whether to convert the value to uppercase

906 regex_engine: The regex engine to use for pattern validation. Default is 'rust-regex'.

907 - `rust-regex` uses the [`regex`](https://docs.rs/regex) Rust

908 crate, which is non-backtracking and therefore more DDoS

909 resistant, but does not support all regex features.

910 - `python-re` use the [`re`](https://docs.python.org/3/library/re.html) module,

911 which supports all regex features, but may be slower.

912 strict: Whether the value should be a string or a value that can be converted to a string

913 coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode).

914 ref: optional unique identifier of the schema, used to reference the schema in other places

915 metadata: Any other information you want to include with the schema, not used by pydantic-core

916 serialization: Custom serialization schema

917 """

918 return _dict_not_none(

919 type='str',

920 pattern=pattern,

921 max_length=max_length,

922 min_length=min_length,

923 strip_whitespace=strip_whitespace,

924 to_lower=to_lower,

925 to_upper=to_upper,

926 regex_engine=regex_engine,

927 strict=strict,

928 coerce_numbers_to_str=coerce_numbers_to_str,

929 ref=ref,

930 metadata=metadata,

931 serialization=serialization,

932 )

933

934

935class BytesSchema(TypedDict, total=False):

936 type: Required[Literal['bytes']]

937 max_length: int

938 min_length: int

939 strict: bool

940 ref: str

941 metadata: dict[str, Any]

942 serialization: SerSchema

943

944

945def bytes_schema(

946 *,

947 max_length: int | None = None,

948 min_length: int | None = None,

949 strict: bool | None = None,

950 ref: str | None = None,

951 metadata: dict[str, Any] | None = None,

952 serialization: SerSchema | None = None,

953) -> BytesSchema:

954 """

955 Returns a schema that matches a bytes value, e.g.:

956

957 ```py

958 from pydantic_core import SchemaValidator, core_schema

959

960 schema = core_schema.bytes_schema(max_length=10, min_length=2)

961 v = SchemaValidator(schema)

962 assert v.validate_python(b'hello') == b'hello'

963 ```

964

965 Args:

966 max_length: The value must be at most this length

967 min_length: The value must be at least this length

968 strict: Whether the value should be a bytes or a value that can be converted to a bytes

969 ref: optional unique identifier of the schema, used to reference the schema in other places

970 metadata: Any other information you want to include with the schema, not used by pydantic-core

971 serialization: Custom serialization schema

972 """

973 return _dict_not_none(

974 type='bytes',

975 max_length=max_length,

976 min_length=min_length,

977 strict=strict,

978 ref=ref,

979 metadata=metadata,

980 serialization=serialization,

981 )

982

983

984class DateSchema(TypedDict, total=False):

985 type: Required[Literal['date']]

986 strict: bool

987 le: date

988 ge: date

989 lt: date

990 gt: date

991 now_op: Literal['past', 'future']

992 # defaults to current local utc offset from `time.localtime().tm_gmtoff`

993 # value is restricted to -86_400 < offset < 86_400:

994 now_utc_offset: int

995 ref: str

996 metadata: dict[str, Any]

997 serialization: SerSchema

998

999

1000def date_schema(

1001 *,

1002 strict: bool | None = None,

1003 le: date | None = None,

1004 ge: date | None = None,

1005 lt: date | None = None,

1006 gt: date | None = None,

1007 now_op: Literal['past', 'future'] | None = None,

1008 now_utc_offset: int | None = None,

1009 ref: str | None = None,

1010 metadata: dict[str, Any] | None = None,

1011 serialization: SerSchema | None = None,

1012) -> DateSchema:

1013 """

1014 Returns a schema that matches a date value, e.g.:

1015

1016 ```py

1017 from datetime import date

1018 from pydantic_core import SchemaValidator, core_schema

1019

1020 schema = core_schema.date_schema(le=date(2020, 1, 1), ge=date(2019, 1, 1))

1021 v = SchemaValidator(schema)

1022 assert v.validate_python(date(2019, 6, 1)) == date(2019, 6, 1)

1023 ```

1024

1025 Args:

1026 strict: Whether the value should be a date or a value that can be converted to a date

1027 le: The value must be less than or equal to this date

1028 ge: The value must be greater than or equal to this date

1029 lt: The value must be strictly less than this date

1030 gt: The value must be strictly greater than this date

1031 now_op: The value must be in the past or future relative to the current date

1032 now_utc_offset: The value must be in the past or future relative to the current date with this utc offset

1033 ref: optional unique identifier of the schema, used to reference the schema in other places

1034 metadata: Any other information you want to include with the schema, not used by pydantic-core

1035 serialization: Custom serialization schema

1036 """

1037 return _dict_not_none(

1038 type='date',

1039 strict=strict,

1040 le=le,

1041 ge=ge,

1042 lt=lt,

1043 gt=gt,

1044 now_op=now_op,

1045 now_utc_offset=now_utc_offset,

1046 ref=ref,

1047 metadata=metadata,

1048 serialization=serialization,

1049 )

1050

1051

1052class TimeSchema(TypedDict, total=False):

1053 type: Required[Literal['time']]

1054 strict: bool

1055 le: time

1056 ge: time

1057 lt: time

1058 gt: time

1059 tz_constraint: Union[Literal['aware', 'naive'], int]

1060 microseconds_precision: Literal['truncate', 'error']

1061 ref: str

1062 metadata: dict[str, Any]

1063 serialization: SerSchema

1064

1065

1066def time_schema(

1067 *,

1068 strict: bool | None = None,

1069 le: time | None = None,

1070 ge: time | None = None,

1071 lt: time | None = None,

1072 gt: time | None = None,

1073 tz_constraint: Literal['aware', 'naive'] | int | None = None,

1074 microseconds_precision: Literal['truncate', 'error'] = 'truncate',

1075 ref: str | None = None,

1076 metadata: dict[str, Any] | None = None,

1077 serialization: SerSchema | None = None,

1078) -> TimeSchema:

1079 """

1080 Returns a schema that matches a time value, e.g.:

1081

1082 ```py

1083 from datetime import time

1084 from pydantic_core import SchemaValidator, core_schema

1085

1086 schema = core_schema.time_schema(le=time(12, 0, 0), ge=time(6, 0, 0))

1087 v = SchemaValidator(schema)

1088 assert v.validate_python(time(9, 0, 0)) == time(9, 0, 0)

1089 ```

1090

1091 Args:

1092 strict: Whether the value should be a time or a value that can be converted to a time

1093 le: The value must be less than or equal to this time

1094 ge: The value must be greater than or equal to this time

1095 lt: The value must be strictly less than this time

1096 gt: The value must be strictly greater than this time

1097 tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset

1098 microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large

1099 ref: optional unique identifier of the schema, used to reference the schema in other places

1100 metadata: Any other information you want to include with the schema, not used by pydantic-core

1101 serialization: Custom serialization schema

1102 """

1103 return _dict_not_none(

1104 type='time',

1105 strict=strict,

1106 le=le,

1107 ge=ge,

1108 lt=lt,

1109 gt=gt,

1110 tz_constraint=tz_constraint,

1111 microseconds_precision=microseconds_precision,

1112 ref=ref,

1113 metadata=metadata,

1114 serialization=serialization,

1115 )

1116

1117

1118class DatetimeSchema(TypedDict, total=False):

1119 type: Required[Literal['datetime']]

1120 strict: bool

1121 le: datetime

1122 ge: datetime

1123 lt: datetime

1124 gt: datetime

1125 now_op: Literal['past', 'future']

1126 tz_constraint: Union[Literal['aware', 'naive'], int]

1127 # defaults to current local utc offset from `time.localtime().tm_gmtoff`

1128 # value is restricted to -86_400 < offset < 86_400 by bounds in generate_self_schema.py

1129 now_utc_offset: int

1130 microseconds_precision: Literal['truncate', 'error'] # default: 'truncate'

1131 ref: str

1132 metadata: dict[str, Any]

1133 serialization: SerSchema

1134

1135

1136def datetime_schema(

1137 *,

1138 strict: bool | None = None,

1139 le: datetime | None = None,

1140 ge: datetime | None = None,

1141 lt: datetime | None = None,

1142 gt: datetime | None = None,

1143 now_op: Literal['past', 'future'] | None = None,

1144 tz_constraint: Literal['aware', 'naive'] | int | None = None,

1145 now_utc_offset: int | None = None,

1146 microseconds_precision: Literal['truncate', 'error'] = 'truncate',

1147 ref: str | None = None,

1148 metadata: dict[str, Any] | None = None,

1149 serialization: SerSchema | None = None,

1150) -> DatetimeSchema:

1151 """

1152 Returns a schema that matches a datetime value, e.g.:

1153

1154 ```py

1155 from datetime import datetime

1156 from pydantic_core import SchemaValidator, core_schema

1157

1158 schema = core_schema.datetime_schema()

1159 v = SchemaValidator(schema)

1160 now = datetime.now()

1161 assert v.validate_python(str(now)) == now

1162 ```

1163

1164 Args:

1165 strict: Whether the value should be a datetime or a value that can be converted to a datetime

1166 le: The value must be less than or equal to this datetime

1167 ge: The value must be greater than or equal to this datetime

1168 lt: The value must be strictly less than this datetime

1169 gt: The value must be strictly greater than this datetime

1170 now_op: The value must be in the past or future relative to the current datetime

1171 tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset

1172 TODO: use of a tzinfo where offset changes based on the datetime is not yet supported

1173 now_utc_offset: The value must be in the past or future relative to the current datetime with this utc offset

1174 microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large

1175 ref: optional unique identifier of the schema, used to reference the schema in other places

1176 metadata: Any other information you want to include with the schema, not used by pydantic-core

1177 serialization: Custom serialization schema

1178 """

1179 return _dict_not_none(

1180 type='datetime',

1181 strict=strict,

1182 le=le,

1183 ge=ge,

1184 lt=lt,

1185 gt=gt,

1186 now_op=now_op,

1187 tz_constraint=tz_constraint,

1188 now_utc_offset=now_utc_offset,

1189 microseconds_precision=microseconds_precision,

1190 ref=ref,

1191 metadata=metadata,

1192 serialization=serialization,

1193 )

1194

1195

1196class TimedeltaSchema(TypedDict, total=False):

1197 type: Required[Literal['timedelta']]

1198 strict: bool

1199 le: timedelta

1200 ge: timedelta

1201 lt: timedelta

1202 gt: timedelta

1203 microseconds_precision: Literal['truncate', 'error']

1204 ref: str

1205 metadata: dict[str, Any]

1206 serialization: SerSchema

1207

1208

1209def timedelta_schema(

1210 *,

1211 strict: bool | None = None,

1212 le: timedelta | None = None,

1213 ge: timedelta | None = None,

1214 lt: timedelta | None = None,

1215 gt: timedelta | None = None,

1216 microseconds_precision: Literal['truncate', 'error'] = 'truncate',

1217 ref: str | None = None,

1218 metadata: dict[str, Any] | None = None,

1219 serialization: SerSchema | None = None,

1220) -> TimedeltaSchema:

1221 """

1222 Returns a schema that matches a timedelta value, e.g.:

1223

1224 ```py

1225 from datetime import timedelta

1226 from pydantic_core import SchemaValidator, core_schema

1227

1228 schema = core_schema.timedelta_schema(le=timedelta(days=1), ge=timedelta(days=0))

1229 v = SchemaValidator(schema)

1230 assert v.validate_python(timedelta(hours=12)) == timedelta(hours=12)

1231 ```

1232

1233 Args:

1234 strict: Whether the value should be a timedelta or a value that can be converted to a timedelta

1235 le: The value must be less than or equal to this timedelta

1236 ge: The value must be greater than or equal to this timedelta

1237 lt: The value must be strictly less than this timedelta

1238 gt: The value must be strictly greater than this timedelta

1239 microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large

1240 ref: optional unique identifier of the schema, used to reference the schema in other places

1241 metadata: Any other information you want to include with the schema, not used by pydantic-core

1242 serialization: Custom serialization schema

1243 """

1244 return _dict_not_none(

1245 type='timedelta',

1246 strict=strict,

1247 le=le,

1248 ge=ge,

1249 lt=lt,

1250 gt=gt,

1251 microseconds_precision=microseconds_precision,

1252 ref=ref,

1253 metadata=metadata,

1254 serialization=serialization,

1255 )

1256

1257

1258class LiteralSchema(TypedDict, total=False):

1259 type: Required[Literal['literal']]

1260 expected: Required[list[Any]]

1261 ref: str

1262 metadata: dict[str, Any]

1263 serialization: SerSchema

1264

1265

1266def literal_schema(

1267 expected: list[Any],

1268 *,

1269 ref: str | None = None,

1270 metadata: dict[str, Any] | None = None,

1271 serialization: SerSchema | None = None,

1272) -> LiteralSchema:

1273 """

1274 Returns a schema that matches a literal value, e.g.:

1275

1276 ```py

1277 from pydantic_core import SchemaValidator, core_schema

1278

1279 schema = core_schema.literal_schema(['hello', 'world'])

1280 v = SchemaValidator(schema)

1281 assert v.validate_python('hello') == 'hello'

1282 ```

1283

1284 Args:

1285 expected: The value must be one of these values

1286 ref: optional unique identifier of the schema, used to reference the schema in other places

1287 metadata: Any other information you want to include with the schema, not used by pydantic-core

1288 serialization: Custom serialization schema

1289 """

1290 return _dict_not_none(type='literal', expected=expected, ref=ref, metadata=metadata, serialization=serialization)

1291

1292

1293class EnumSchema(TypedDict, total=False):

1294 type: Required[Literal['enum']]

1295 cls: Required[Any]

1296 members: Required[list[Any]]

1297 sub_type: Literal['str', 'int', 'float']

1298 missing: Callable[[Any], Any]

1299 strict: bool

1300 ref: str

1301 metadata: dict[str, Any]

1302 serialization: SerSchema

1303

1304

1305def enum_schema(

1306 cls: Any,

1307 members: list[Any],

1308 *,

1309 sub_type: Literal['str', 'int', 'float'] | None = None,

1310 missing: Callable[[Any], Any] | None = None,

1311 strict: bool | None = None,

1312 ref: str | None = None,

1313 metadata: dict[str, Any] | None = None,

1314 serialization: SerSchema | None = None,

1315) -> EnumSchema:

1316 """

1317 Returns a schema that matches an enum value, e.g.:

1318

1319 ```py

1320 from enum import Enum

1321 from pydantic_core import SchemaValidator, core_schema

1322

1323 class Color(Enum):

1324 RED = 1

1325 GREEN = 2

1326 BLUE = 3

1327

1328 schema = core_schema.enum_schema(Color, list(Color.__members__.values()))

1329 v = SchemaValidator(schema)

1330 assert v.validate_python(2) is Color.GREEN

1331 ```

1332

1333 Args:

1334 cls: The enum class

1335 members: The members of the enum, generally `list(MyEnum.__members__.values())`

1336 sub_type: The type of the enum, either 'str' or 'int' or None for plain enums

1337 missing: A function to use when the value is not found in the enum, from `_missing_`

1338 strict: Whether to use strict mode, defaults to False

1339 ref: optional unique identifier of the schema, used to reference the schema in other places

1340 metadata: Any other information you want to include with the schema, not used by pydantic-core

1341 serialization: Custom serialization schema

1342 """

1343 return _dict_not_none(

1344 type='enum',

1345 cls=cls,

1346 members=members,

1347 sub_type=sub_type,

1348 missing=missing,

1349 strict=strict,

1350 ref=ref,

1351 metadata=metadata,

1352 serialization=serialization,

1353 )

1354

1355

1356class MissingSentinelSchema(TypedDict, total=False):

1357 type: Required[Literal['missing-sentinel']]

1358 metadata: dict[str, Any]

1359 serialization: SerSchema

1360

1361

1362def missing_sentinel_schema(

1363 metadata: dict[str, Any] | None = None,

1364 serialization: SerSchema | None = None,

1365) -> MissingSentinelSchema:

1366 """Returns a schema for the `MISSING` sentinel."""

1367

1368 return _dict_not_none(

1369 type='missing-sentinel',

1370 metadata=metadata,

1371 serialization=serialization,

1372 )

1373

1374

1375# must match input/parse_json.rs::JsonType::try_from

1376JsonType = Literal['null', 'bool', 'int', 'float', 'str', 'list', 'dict']

1377

1378

1379class IsInstanceSchema(TypedDict, total=False):

1380 type: Required[Literal['is-instance']]

1381 cls: Required[Any]

1382 cls_repr: str

1383 ref: str

1384 metadata: dict[str, Any]

1385 serialization: SerSchema

1386

1387

1388def is_instance_schema(

1389 cls: Any,

1390 *,

1391 cls_repr: str | None = None,

1392 ref: str | None = None,

1393 metadata: dict[str, Any] | None = None,

1394 serialization: SerSchema | None = None,

1395) -> IsInstanceSchema:

1396 """

1397 Returns a schema that checks if a value is an instance of a class, equivalent to python's `isinstance` method, e.g.:

1398

1399 ```py

1400 from pydantic_core import SchemaValidator, core_schema

1401

1402 class A:

1403 pass

1404

1405 schema = core_schema.is_instance_schema(cls=A)

1406 v = SchemaValidator(schema)

1407 v.validate_python(A())

1408 ```

1409

1410 Args:

1411 cls: The value must be an instance of this class

1412 cls_repr: If provided this string is used in the validator name instead of `repr(cls)`

1413 ref: optional unique identifier of the schema, used to reference the schema in other places

1414 metadata: Any other information you want to include with the schema, not used by pydantic-core

1415 serialization: Custom serialization schema

1416 """

1417 return _dict_not_none(

1418 type='is-instance', cls=cls, cls_repr=cls_repr, ref=ref, metadata=metadata, serialization=serialization

1419 )

1420

1421

1422class IsSubclassSchema(TypedDict, total=False):

1423 type: Required[Literal['is-subclass']]

1424 cls: Required[type[Any]]

1425 cls_repr: str

1426 ref: str

1427 metadata: dict[str, Any]

1428 serialization: SerSchema

1429

1430

1431def is_subclass_schema(

1432 cls: type[Any],

1433 *,

1434 cls_repr: str | None = None,

1435 ref: str | None = None,

1436 metadata: dict[str, Any] | None = None,

1437 serialization: SerSchema | None = None,

1438) -> IsInstanceSchema:

1439 """

1440 Returns a schema that checks if a value is a subtype of a class, equivalent to python's `issubclass` method, e.g.:

1441

1442 ```py

1443 from pydantic_core import SchemaValidator, core_schema

1444

1445 class A:

1446 pass

1447

1448 class B(A):

1449 pass

1450

1451 schema = core_schema.is_subclass_schema(cls=A)

1452 v = SchemaValidator(schema)

1453 v.validate_python(B)

1454 ```

1455

1456 Args:

1457 cls: The value must be a subclass of this class

1458 cls_repr: If provided this string is used in the validator name instead of `repr(cls)`

1459 ref: optional unique identifier of the schema, used to reference the schema in other places

1460 metadata: Any other information you want to include with the schema, not used by pydantic-core

1461 serialization: Custom serialization schema

1462 """

1463 return _dict_not_none(

1464 type='is-subclass', cls=cls, cls_repr=cls_repr, ref=ref, metadata=metadata, serialization=serialization

1465 )

1466

1467

1468class CallableSchema(TypedDict, total=False):

1469 type: Required[Literal['callable']]

1470 ref: str

1471 metadata: dict[str, Any]

1472 serialization: SerSchema

1473

1474

1475def callable_schema(

1476 *, ref: str | None = None, metadata: dict[str, Any] | None = None, serialization: SerSchema | None = None

1477) -> CallableSchema:

1478 """

1479 Returns a schema that checks if a value is callable, equivalent to python's `callable` method, e.g.:

1480

1481 ```py

1482 from pydantic_core import SchemaValidator, core_schema

1483

1484 schema = core_schema.callable_schema()

1485 v = SchemaValidator(schema)

1486 v.validate_python(min)

1487 ```

1488

1489 Args:

1490 ref: optional unique identifier of the schema, used to reference the schema in other places

1491 metadata: Any other information you want to include with the schema, not used by pydantic-core

1492 serialization: Custom serialization schema

1493 """

1494 return _dict_not_none(type='callable', ref=ref, metadata=metadata, serialization=serialization)

1495

1496

1497class UuidSchema(TypedDict, total=False):

1498 type: Required[Literal['uuid']]

1499 version: Literal[1, 3, 4, 5, 7]

1500 strict: bool

1501 ref: str

1502 metadata: dict[str, Any]

1503 serialization: SerSchema

1504

1505

1506def uuid_schema(

1507 *,

1508 version: Literal[1, 3, 4, 5, 6, 7, 8] | None = None,

1509 strict: bool | None = None,

1510 ref: str | None = None,

1511 metadata: dict[str, Any] | None = None,

1512 serialization: SerSchema | None = None,

1513) -> UuidSchema:

1514 return _dict_not_none(

1515 type='uuid', version=version, strict=strict, ref=ref, metadata=metadata, serialization=serialization

1516 )

1517

1518

1519class IncExSeqSerSchema(TypedDict, total=False):

1520 type: Required[Literal['include-exclude-sequence']]

1521 include: set[int]

1522 exclude: set[int]

1523

1524

1525def filter_seq_schema(*, include: set[int] | None = None, exclude: set[int] | None = None) -> IncExSeqSerSchema:

1526 return _dict_not_none(type='include-exclude-sequence', include=include, exclude=exclude)

1527

1528

1529IncExSeqOrElseSerSchema = Union[IncExSeqSerSchema, SerSchema]

1530

1531

1532class ListSchema(TypedDict, total=False):

1533 type: Required[Literal['list']]

1534 items_schema: CoreSchema

1535 min_length: int

1536 max_length: int

1537 fail_fast: bool

1538 strict: bool

1539 ref: str

1540 metadata: dict[str, Any]

1541 serialization: IncExSeqOrElseSerSchema

1542

1543

1544def list_schema(

1545 items_schema: CoreSchema | None = None,

1546 *,

1547 min_length: int | None = None,

1548 max_length: int | None = None,

1549 fail_fast: bool | None = None,

1550 strict: bool | None = None,

1551 ref: str | None = None,

1552 metadata: dict[str, Any] | None = None,

1553 serialization: IncExSeqOrElseSerSchema | None = None,

1554) -> ListSchema:

1555 """

1556 Returns a schema that matches a list value, e.g.:

1557

1558 ```py

1559 from pydantic_core import SchemaValidator, core_schema

1560

1561 schema = core_schema.list_schema(core_schema.int_schema(), min_length=0, max_length=10)

1562 v = SchemaValidator(schema)

1563 assert v.validate_python(['4']) == [4]

1564 ```

1565

1566 Args:

1567 items_schema: The value must be a list of items that match this schema

1568 min_length: The value must be a list with at least this many items

1569 max_length: The value must be a list with at most this many items

1570 fail_fast: Stop validation on the first error

1571 strict: The value must be a list with exactly this many items

1572 ref: optional unique identifier of the schema, used to reference the schema in other places

1573 metadata: Any other information you want to include with the schema, not used by pydantic-core

1574 serialization: Custom serialization schema

1575 """

1576 return _dict_not_none(

1577 type='list',

1578 items_schema=items_schema,

1579 min_length=min_length,

1580 max_length=max_length,

1581 fail_fast=fail_fast,

1582 strict=strict,

1583 ref=ref,

1584 metadata=metadata,

1585 serialization=serialization,

1586 )

1587

1588

1589# @deprecated('tuple_positional_schema is deprecated. Use pydantic_core.core_schema.tuple_schema instead.')

1590def tuple_positional_schema(

1591 items_schema: list[CoreSchema],

1592 *,

1593 extras_schema: CoreSchema | None = None,

1594 strict: bool | None = None,

1595 ref: str | None = None,

1596 metadata: dict[str, Any] | None = None,

1597 serialization: IncExSeqOrElseSerSchema | None = None,

1598) -> TupleSchema:

1599 """

1600 Returns a schema that matches a tuple of schemas, e.g.:

1601

1602 ```py

1603 from pydantic_core import SchemaValidator, core_schema

1604

1605 schema = core_schema.tuple_positional_schema(

1606 [core_schema.int_schema(), core_schema.str_schema()]

1607 )

1608 v = SchemaValidator(schema)

1609 assert v.validate_python((1, 'hello')) == (1, 'hello')

1610 ```

1611

1612 Args:

1613 items_schema: The value must be a tuple with items that match these schemas

1614 extras_schema: The value must be a tuple with items that match this schema

1615 This was inspired by JSON schema's `prefixItems` and `items` fields.

1616 In python's `typing.Tuple`, you can't specify a type for "extra" items -- they must all be the same type

1617 if the length is variable. So this field won't be set from a `typing.Tuple` annotation on a pydantic model.

1618 strict: The value must be a tuple with exactly this many items

1619 ref: optional unique identifier of the schema, used to reference the schema in other places

1620 metadata: Any other information you want to include with the schema, not used by pydantic-core

1621 serialization: Custom serialization schema

1622 """

1623 if extras_schema is not None:

1624 variadic_item_index = len(items_schema)

1625 items_schema = items_schema + [extras_schema]

1626 else:

1627 variadic_item_index = None

1628 return tuple_schema(

1629 items_schema=items_schema,

1630 variadic_item_index=variadic_item_index,

1631 strict=strict,

1632 ref=ref,

1633 metadata=metadata,

1634 serialization=serialization,

1635 )

1636

1637

1638# @deprecated('tuple_variable_schema is deprecated. Use pydantic_core.core_schema.tuple_schema instead.')

1639def tuple_variable_schema(

1640 items_schema: CoreSchema | None = None,

1641 *,

1642 min_length: int | None = None,

1643 max_length: int | None = None,

1644 strict: bool | None = None,

1645 ref: str | None = None,

1646 metadata: dict[str, Any] | None = None,

1647 serialization: IncExSeqOrElseSerSchema | None = None,

1648) -> TupleSchema:

1649 """

1650 Returns a schema that matches a tuple of a given schema, e.g.:

1651

1652 ```py

1653 from pydantic_core import SchemaValidator, core_schema

1654

1655 schema = core_schema.tuple_variable_schema(

1656 items_schema=core_schema.int_schema(), min_length=0, max_length=10

1657 )

1658 v = SchemaValidator(schema)

1659 assert v.validate_python(('1', 2, 3)) == (1, 2, 3)

1660 ```

1661

1662 Args:

1663 items_schema: The value must be a tuple with items that match this schema

1664 min_length: The value must be a tuple with at least this many items

1665 max_length: The value must be a tuple with at most this many items

1666 strict: The value must be a tuple with exactly this many items

1667 ref: Optional unique identifier of the schema, used to reference the schema in other places

1668 metadata: Any other information you want to include with the schema, not used by pydantic-core

1669 serialization: Custom serialization schema

1670 """

1671 return tuple_schema(

1672 items_schema=[items_schema or any_schema()],

1673 variadic_item_index=0,

1674 min_length=min_length,

1675 max_length=max_length,

1676 strict=strict,

1677 ref=ref,

1678 metadata=metadata,

1679 serialization=serialization,

1680 )

1681

1682

1683class TupleSchema(TypedDict, total=False):

1684 type: Required[Literal['tuple']]

1685 items_schema: Required[list[CoreSchema]]

1686 variadic_item_index: int

1687 min_length: int

1688 max_length: int

1689 fail_fast: bool

1690 strict: bool

1691 ref: str

1692 metadata: dict[str, Any]

1693 serialization: IncExSeqOrElseSerSchema

1694

1695

1696def tuple_schema(

1697 items_schema: list[CoreSchema],

1698 *,

1699 variadic_item_index: int | None = None,

1700 min_length: int | None = None,

1701 max_length: int | None = None,

1702 fail_fast: bool | None = None,

1703 strict: bool | None = None,

1704 ref: str | None = None,

1705 metadata: dict[str, Any] | None = None,

1706 serialization: IncExSeqOrElseSerSchema | None = None,

1707) -> TupleSchema:

1708 """

1709 Returns a schema that matches a tuple of schemas, with an optional variadic item, e.g.:

1710

1711 ```py

1712 from pydantic_core import SchemaValidator, core_schema

1713

1714 schema = core_schema.tuple_schema(

1715 [core_schema.int_schema(), core_schema.str_schema(), core_schema.float_schema()],

1716 variadic_item_index=1,

1717 )

1718 v = SchemaValidator(schema)

1719 assert v.validate_python((1, 'hello', 'world', 1.5)) == (1, 'hello', 'world', 1.5)

1720 ```

1721

1722 Args:

1723 items_schema: The value must be a tuple with items that match these schemas

1724 variadic_item_index: The index of the schema in `items_schema` to be treated as variadic (following PEP 646)

1725 min_length: The value must be a tuple with at least this many items

1726 max_length: The value must be a tuple with at most this many items

1727 fail_fast: Stop validation on the first error

1728 strict: The value must be a tuple with exactly this many items

1729 ref: Optional unique identifier of the schema, used to reference the schema in other places

1730 metadata: Any other information you want to include with the schema, not used by pydantic-core

1731 serialization: Custom serialization schema

1732 """

1733 return _dict_not_none(

1734 type='tuple',

1735 items_schema=items_schema,

1736 variadic_item_index=variadic_item_index,

1737 min_length=min_length,

1738 max_length=max_length,

1739 fail_fast=fail_fast,

1740 strict=strict,

1741 ref=ref,

1742 metadata=metadata,

1743 serialization=serialization,

1744 )

1745

1746

1747class SetSchema(TypedDict, total=False):

1748 type: Required[Literal['set']]

1749 items_schema: CoreSchema

1750 min_length: int

1751 max_length: int

1752 fail_fast: bool

1753 strict: bool

1754 ref: str

1755 metadata: dict[str, Any]

1756 serialization: SerSchema

1757

1758

1759def set_schema(

1760 items_schema: CoreSchema | None = None,

1761 *,

1762 min_length: int | None = None,

1763 max_length: int | None = None,

1764 fail_fast: bool | None = None,

1765 strict: bool | None = None,

1766 ref: str | None = None,

1767 metadata: dict[str, Any] | None = None,

1768 serialization: SerSchema | None = None,

1769) -> SetSchema:

1770 """

1771 Returns a schema that matches a set of a given schema, e.g.:

1772

1773 ```py

1774 from pydantic_core import SchemaValidator, core_schema

1775

1776 schema = core_schema.set_schema(

1777 items_schema=core_schema.int_schema(), min_length=0, max_length=10

1778 )

1779 v = SchemaValidator(schema)

1780 assert v.validate_python({1, '2', 3}) == {1, 2, 3}

1781 ```

1782

1783 Args:

1784 items_schema: The value must be a set with items that match this schema

1785 min_length: The value must be a set with at least this many items

1786 max_length: The value must be a set with at most this many items

1787 fail_fast: Stop validation on the first error

1788 strict: The value must be a set with exactly this many items

1789 ref: optional unique identifier of the schema, used to reference the schema in other places

1790 metadata: Any other information you want to include with the schema, not used by pydantic-core

1791 serialization: Custom serialization schema

1792 """

1793 return _dict_not_none(

1794 type='set',

1795 items_schema=items_schema,

1796 min_length=min_length,

1797 max_length=max_length,

1798 fail_fast=fail_fast,

1799 strict=strict,

1800 ref=ref,

1801 metadata=metadata,

1802 serialization=serialization,

1803 )

1804

1805

1806class FrozenSetSchema(TypedDict, total=False):

1807 type: Required[Literal['frozenset']]

1808 items_schema: CoreSchema

1809 min_length: int

1810 max_length: int

1811 fail_fast: bool

1812 strict: bool

1813 ref: str

1814 metadata: dict[str, Any]

1815 serialization: SerSchema

1816

1817

1818def frozenset_schema(

1819 items_schema: CoreSchema | None = None,

1820 *,

1821 min_length: int | None = None,

1822 max_length: int | None = None,

1823 fail_fast: bool | None = None,

1824 strict: bool | None = None,

1825 ref: str | None = None,

1826 metadata: dict[str, Any] | None = None,

1827 serialization: SerSchema | None = None,

1828) -> FrozenSetSchema:

1829 """

1830 Returns a schema that matches a frozenset of a given schema, e.g.:

1831

1832 ```py

1833 from pydantic_core import SchemaValidator, core_schema

1834

1835 schema = core_schema.frozenset_schema(

1836 items_schema=core_schema.int_schema(), min_length=0, max_length=10

1837 )

1838 v = SchemaValidator(schema)

1839 assert v.validate_python(frozenset(range(3))) == frozenset({0, 1, 2})

1840 ```

1841

1842 Args:

1843 items_schema: The value must be a frozenset with items that match this schema

1844 min_length: The value must be a frozenset with at least this many items

1845 max_length: The value must be a frozenset with at most this many items

1846 fail_fast: Stop validation on the first error

1847 strict: The value must be a frozenset with exactly this many items

1848 ref: optional unique identifier of the schema, used to reference the schema in other places

1849 metadata: Any other information you want to include with the schema, not used by pydantic-core

1850 serialization: Custom serialization schema

1851 """

1852 return _dict_not_none(

1853 type='frozenset',

1854 items_schema=items_schema,

1855 min_length=min_length,

1856 max_length=max_length,

1857 fail_fast=fail_fast,

1858 strict=strict,

1859 ref=ref,

1860 metadata=metadata,

1861 serialization=serialization,

1862 )

1863

1864

1865class GeneratorSchema(TypedDict, total=False):

1866 type: Required[Literal['generator']]

1867 items_schema: CoreSchema

1868 min_length: int

1869 max_length: int

1870 ref: str

1871 metadata: dict[str, Any]

1872 serialization: IncExSeqOrElseSerSchema

1873

1874

1875def generator_schema(

1876 items_schema: CoreSchema | None = None,

1877 *,

1878 min_length: int | None = None,

1879 max_length: int | None = None,

1880 ref: str | None = None,

1881 metadata: dict[str, Any] | None = None,

1882 serialization: IncExSeqOrElseSerSchema | None = None,

1883) -> GeneratorSchema:

1884 """

1885 Returns a schema that matches a generator value, e.g.:

1886

1887 ```py

1888 from typing import Iterator

1889 from pydantic_core import SchemaValidator, core_schema

1890

1891 def gen() -> Iterator[int]:

1892 yield 1

1893

1894 schema = core_schema.generator_schema(items_schema=core_schema.int_schema())

1895 v = SchemaValidator(schema)

1896 v.validate_python(gen())

1897 ```

1898

1899 Unlike other types, validated generators do not raise ValidationErrors eagerly,

1900 but instead will raise a ValidationError when a violating value is actually read from the generator.

1901 This is to ensure that "validated" generators retain the benefit of lazy evaluation.

1902

1903 Args:

1904 items_schema: The value must be a generator with items that match this schema

1905 min_length: The value must be a generator that yields at least this many items

1906 max_length: The value must be a generator that yields at most this many items

1907 ref: optional unique identifier of the schema, used to reference the schema in other places

1908 metadata: Any other information you want to include with the schema, not used by pydantic-core

1909 serialization: Custom serialization schema

1910 """

1911 return _dict_not_none(

1912 type='generator',

1913 items_schema=items_schema,

1914 min_length=min_length,

1915 max_length=max_length,

1916 ref=ref,

1917 metadata=metadata,

1918 serialization=serialization,

1919 )

1920

1921

1922IncExDict = set[Union[int, str]]

1923

1924

1925class IncExDictSerSchema(TypedDict, total=False):

1926 type: Required[Literal['include-exclude-dict']]

1927 include: IncExDict

1928 exclude: IncExDict

1929

1930

1931def filter_dict_schema(*, include: IncExDict | None = None, exclude: IncExDict | None = None) -> IncExDictSerSchema:

1932 return _dict_not_none(type='include-exclude-dict', include=include, exclude=exclude)

1933

1934

1935IncExDictOrElseSerSchema = Union[IncExDictSerSchema, SerSchema]

1936

1937

1938class DictSchema(TypedDict, total=False):

1939 type: Required[Literal['dict']]

1940 keys_schema: CoreSchema # default: AnySchema

1941 values_schema: CoreSchema # default: AnySchema

1942 min_length: int

1943 max_length: int

1944 fail_fast: bool

1945 strict: bool

1946 ref: str

1947 metadata: dict[str, Any]

1948 serialization: IncExDictOrElseSerSchema

1949

1950

1951def dict_schema(

1952 keys_schema: CoreSchema | None = None,

1953 values_schema: CoreSchema | None = None,

1954 *,

1955 min_length: int | None = None,

1956 max_length: int | None = None,

1957 fail_fast: bool | None = None,

1958 strict: bool | None = None,

1959 ref: str | None = None,

1960 metadata: dict[str, Any] | None = None,

1961 serialization: SerSchema | None = None,

1962) -> DictSchema:

1963 """

1964 Returns a schema that matches a dict value, e.g.:

1965

1966 ```py

1967 from pydantic_core import SchemaValidator, core_schema

1968

1969 schema = core_schema.dict_schema(

1970 keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema()

1971 )

1972 v = SchemaValidator(schema)

1973 assert v.validate_python({'a': '1', 'b': 2}) == {'a': 1, 'b': 2}

1974 ```

1975

1976 Args:

1977 keys_schema: The value must be a dict with keys that match this schema

1978 values_schema: The value must be a dict with values that match this schema

1979 min_length: The value must be a dict with at least this many items

1980 max_length: The value must be a dict with at most this many items

1981 fail_fast: Stop validation on the first error

1982 strict: Whether the keys and values should be validated with strict mode

1983 ref: optional unique identifier of the schema, used to reference the schema in other places

1984 metadata: Any other information you want to include with the schema, not used by pydantic-core

1985 serialization: Custom serialization schema

1986 """

1987 return _dict_not_none(

1988 type='dict',

1989 keys_schema=keys_schema,

1990 values_schema=values_schema,

1991 min_length=min_length,

1992 max_length=max_length,

1993 fail_fast=fail_fast,

1994 strict=strict,

1995 ref=ref,

1996 metadata=metadata,

1997 serialization=serialization,

1998 )

1999

2000

2001# (input_value: Any, /) -> Any

2002NoInfoValidatorFunction = Callable[[Any], Any]

2003

2004

2005class NoInfoValidatorFunctionSchema(TypedDict):

2006 type: Literal['no-info']

2007 function: NoInfoValidatorFunction

2008

2009

2010# (input_value: Any, info: ValidationInfo, /) -> Any

2011WithInfoValidatorFunction = Callable[[Any, ValidationInfo[Any]], Any]

2012

2013

2014class WithInfoValidatorFunctionSchema(TypedDict, total=False):

2015 type: Required[Literal['with-info']]

2016 function: Required[WithInfoValidatorFunction]

2017 field_name: str # deprecated

2018

2019

2020ValidationFunction = Union[NoInfoValidatorFunctionSchema, WithInfoValidatorFunctionSchema]

2021

2022

2023class _ValidatorFunctionSchema(TypedDict, total=False):

2024 function: Required[ValidationFunction]

2025 schema: Required[CoreSchema]

2026 ref: str

2027 metadata: dict[str, Any]

2028 serialization: SerSchema

2029

2030

2031class BeforeValidatorFunctionSchema(_ValidatorFunctionSchema, total=False):

2032 type: Required[Literal['function-before']]

2033 json_schema_input_schema: CoreSchema

2034

2035

2036def no_info_before_validator_function(

2037 function: NoInfoValidatorFunction,

2038 schema: CoreSchema,

2039 *,

2040 ref: str | None = None,

2041 json_schema_input_schema: CoreSchema | None = None,

2042 metadata: dict[str, Any] | None = None,

2043 serialization: SerSchema | None = None,

2044) -> BeforeValidatorFunctionSchema:

2045 """

2046 Returns a schema that calls a validator function before validating, no `info` argument is provided, e.g.:

2047

2048 ```py

2049 from pydantic_core import SchemaValidator, core_schema

2050

2051 def fn(v: bytes) -> str:

2052 return v.decode() + 'world'

2053

2054 func_schema = core_schema.no_info_before_validator_function(

2055 function=fn, schema=core_schema.str_schema()

2056 )

2057 schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

2058

2059 v = SchemaValidator(schema)

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

2061 ```

2062

2063 Args:

2064 function: The validator function to call

2065 schema: The schema to validate the output of the validator function

2066 ref: optional unique identifier of the schema, used to reference the schema in other places

2067 json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type

2068 metadata: Any other information you want to include with the schema, not used by pydantic-core

2069 serialization: Custom serialization schema

2070 """

2071 return _dict_not_none(

2072 type='function-before',

2073 function={'type': 'no-info', 'function': function},

2074 schema=schema,

2075 ref=ref,

2076 json_schema_input_schema=json_schema_input_schema,

2077 metadata=metadata,

2078 serialization=serialization,

2079 )

2080

2081

2082def with_info_before_validator_function(

2083 function: WithInfoValidatorFunction,

2084 schema: CoreSchema,

2085 *,

2086 field_name: str | None = None,

2087 ref: str | None = None,

2088 json_schema_input_schema: CoreSchema | None = None,

2089 metadata: dict[str, Any] | None = None,

2090 serialization: SerSchema | None = None,

2091) -> BeforeValidatorFunctionSchema:

2092 """

2093 Returns a schema that calls a validator function before validation, the function is called with

2094 an `info` argument, e.g.:

2095

2096 ```py

2097 from pydantic_core import SchemaValidator, core_schema

2098

2099 def fn(v: bytes, info: core_schema.ValidationInfo) -> str:

2100 assert info.data is not None

2101 assert info.field_name is not None

2102 return v.decode() + 'world'

2103

2104 func_schema = core_schema.with_info_before_validator_function(

2105 function=fn, schema=core_schema.str_schema()

2106 )

2107 schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

2108

2109 v = SchemaValidator(schema)

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

2111 ```

2112

2113 Args:

2114 function: The validator function to call

2115 field_name: The name of the field this validator is applied to, if any (deprecated)

2116 schema: The schema to validate the output of the validator function

2117 ref: optional unique identifier of the schema, used to reference the schema in other places

2118 json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type

2119 metadata: Any other information you want to include with the schema, not used by pydantic-core

2120 serialization: Custom serialization schema

2121 """

2122 if field_name is not None:

2123 warnings.warn(

2124 'The `field_name` argument on `with_info_before_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',

2125 DeprecationWarning,

2126 stacklevel=2,

2127 )

2128

2129 return _dict_not_none(

2130 type='function-before',

2131 function=_dict_not_none(type='with-info', function=function, field_name=field_name),

2132 schema=schema,

2133 ref=ref,

2134 json_schema_input_schema=json_schema_input_schema,

2135 metadata=metadata,

2136 serialization=serialization,

2137 )

2138

2139

2140class AfterValidatorFunctionSchema(_ValidatorFunctionSchema, total=False):

2141 type: Required[Literal['function-after']]

2142

2143

2144def no_info_after_validator_function(

2145 function: NoInfoValidatorFunction,

2146 schema: CoreSchema,

2147 *,

2148 ref: str | None = None,

2149 json_schema_input_schema: CoreSchema | None = None,

2150 metadata: dict[str, Any] | None = None,

2151 serialization: SerSchema | None = None,

2152) -> AfterValidatorFunctionSchema:

2153 """

2154 Returns a schema that calls a validator function after validating, no `info` argument is provided, e.g.:

2155

2156 ```py

2157 from pydantic_core import SchemaValidator, core_schema

2158

2159 def fn(v: str) -> str:

2160 return v + 'world'

2161

2162 func_schema = core_schema.no_info_after_validator_function(fn, core_schema.str_schema())

2163 schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

2164

2165 v = SchemaValidator(schema)

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

2167 ```

2168

2169 Args:

2170 function: The validator function to call after the schema is validated

2171 schema: The schema to validate before the validator function

2172 ref: optional unique identifier of the schema, used to reference the schema in other places

2173 json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type

2174 metadata: Any other information you want to include with the schema, not used by pydantic-core

2175 serialization: Custom serialization schema

2176 """

2177 return _dict_not_none(

2178 type='function-after',

2179 function={'type': 'no-info', 'function': function},

2180 schema=schema,

2181 ref=ref,

2182 json_schema_input_schema=json_schema_input_schema,

2183 metadata=metadata,

2184 serialization=serialization,

2185 )

2186

2187

2188def with_info_after_validator_function(

2189 function: WithInfoValidatorFunction,

2190 schema: CoreSchema,

2191 *,

2192 field_name: str | None = None,

2193 ref: str | None = None,

2194 metadata: dict[str, Any] | None = None,

2195 serialization: SerSchema | None = None,

2196) -> AfterValidatorFunctionSchema:

2197 """

2198 Returns a schema that calls a validator function after validation, the function is called with

2199 an `info` argument, e.g.:

2200

2201 ```py

2202 from pydantic_core import SchemaValidator, core_schema

2203

2204 def fn(v: str, info: core_schema.ValidationInfo) -> str:

2205 assert info.data is not None

2206 assert info.field_name is not None

2207 return v + 'world'

2208

2209 func_schema = core_schema.with_info_after_validator_function(

2210 function=fn, schema=core_schema.str_schema()

2211 )

2212 schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

2213

2214 v = SchemaValidator(schema)

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

2216 ```

2217

2218 Args:

2219 function: The validator function to call after the schema is validated

2220 schema: The schema to validate before the validator function

2221 field_name: The name of the field this validator is applied to, if any (deprecated)

2222 ref: optional unique identifier of the schema, used to reference the schema in other places

2223 metadata: Any other information you want to include with the schema, not used by pydantic-core

2224 serialization: Custom serialization schema

2225 """

2226 if field_name is not None:

2227 warnings.warn(

2228 'The `field_name` argument on `with_info_after_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',

2229 DeprecationWarning,

2230 stacklevel=2,

2231 )

2232

2233 return _dict_not_none(

2234 type='function-after',

2235 function=_dict_not_none(type='with-info', function=function, field_name=field_name),

2236 schema=schema,

2237 ref=ref,

2238 metadata=metadata,

2239 serialization=serialization,

2240 )

2241

2242

2243class ValidatorFunctionWrapHandler(Protocol):

2244 def __call__(self, input_value: Any, outer_location: str | int | None = None, /) -> Any: # pragma: no cover

2245 ...

2246

2247

2248# (input_value: Any, validator: ValidatorFunctionWrapHandler, /) -> Any

2249NoInfoWrapValidatorFunction = Callable[[Any, ValidatorFunctionWrapHandler], Any]

2250

2251

2252class NoInfoWrapValidatorFunctionSchema(TypedDict):

2253 type: Literal['no-info']

2254 function: NoInfoWrapValidatorFunction

2255

2256

2257# (input_value: Any, validator: ValidatorFunctionWrapHandler, info: ValidationInfo, /) -> Any

2258WithInfoWrapValidatorFunction = Callable[[Any, ValidatorFunctionWrapHandler, ValidationInfo[Any]], Any]

2259

2260

2261class WithInfoWrapValidatorFunctionSchema(TypedDict, total=False):

2262 type: Required[Literal['with-info']]

2263 function: Required[WithInfoWrapValidatorFunction]

2264 field_name: str # deprecated

2265

2266

2267WrapValidatorFunction = Union[NoInfoWrapValidatorFunctionSchema, WithInfoWrapValidatorFunctionSchema]

2268

2269

2270class WrapValidatorFunctionSchema(TypedDict, total=False):

2271 type: Required[Literal['function-wrap']]

2272 function: Required[WrapValidatorFunction]

2273 schema: Required[CoreSchema]

2274 ref: str

2275 json_schema_input_schema: CoreSchema

2276 metadata: dict[str, Any]

2277 serialization: SerSchema

2278

2279

2280def no_info_wrap_validator_function(

2281 function: NoInfoWrapValidatorFunction,

2282 schema: CoreSchema,

2283 *,

2284 ref: str | None = None,

2285 json_schema_input_schema: CoreSchema | None = None,

2286 metadata: dict[str, Any] | None = None,

2287 serialization: SerSchema | None = None,

2288) -> WrapValidatorFunctionSchema:

2289 """

2290 Returns a schema which calls a function with a `validator` callable argument which can

2291 optionally be used to call inner validation with the function logic, this is much like the

2292 "onion" implementation of middleware in many popular web frameworks, no `info` argument is passed, e.g.:

2293

2294 ```py

2295 from pydantic_core import SchemaValidator, core_schema

2296

2297 def fn(

2298 v: str,

2299 validator: core_schema.ValidatorFunctionWrapHandler,

2300 ) -> str:

2301 return validator(input_value=v) + 'world'

2302

2303 schema = core_schema.no_info_wrap_validator_function(

2304 function=fn, schema=core_schema.str_schema()

2305 )

2306 v = SchemaValidator(schema)

2307 assert v.validate_python('hello ') == 'hello world'

2308 ```

2309

2310 Args:

2311 function: The validator function to call

2312 schema: The schema to validate the output of the validator function

2313 ref: optional unique identifier of the schema, used to reference the schema in other places

2314 json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type

2315 metadata: Any other information you want to include with the schema, not used by pydantic-core

2316 serialization: Custom serialization schema

2317 """

2318 return _dict_not_none(

2319 type='function-wrap',

2320 function={'type': 'no-info', 'function': function},

2321 schema=schema,

2322 json_schema_input_schema=json_schema_input_schema,

2323 ref=ref,

2324 metadata=metadata,

2325 serialization=serialization,

2326 )

2327

2328

2329def with_info_wrap_validator_function(

2330 function: WithInfoWrapValidatorFunction,

2331 schema: CoreSchema,

2332 *,

2333 field_name: str | None = None,

2334 json_schema_input_schema: CoreSchema | None = None,

2335 ref: str | None = None,

2336 metadata: dict[str, Any] | None = None,

2337 serialization: SerSchema | None = None,

2338) -> WrapValidatorFunctionSchema:

2339 """

2340 Returns a schema which calls a function with a `validator` callable argument which can

2341 optionally be used to call inner validation with the function logic, this is much like the

2342 "onion" implementation of middleware in many popular web frameworks, an `info` argument is also passed, e.g.:

2343

2344 ```py

2345 from pydantic_core import SchemaValidator, core_schema

2346

2347 def fn(

2348 v: str,

2349 validator: core_schema.ValidatorFunctionWrapHandler,

2350 info: core_schema.ValidationInfo,

2351 ) -> str:

2352 return validator(input_value=v) + 'world'

2353

2354 schema = core_schema.with_info_wrap_validator_function(

2355 function=fn, schema=core_schema.str_schema()

2356 )

2357 v = SchemaValidator(schema)

2358 assert v.validate_python('hello ') == 'hello world'

2359 ```

2360

2361 Args:

2362 function: The validator function to call

2363 schema: The schema to validate the output of the validator function

2364 field_name: The name of the field this validator is applied to, if any (deprecated)

2365 json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type

2366 ref: optional unique identifier of the schema, used to reference the schema in other places

2367 metadata: Any other information you want to include with the schema, not used by pydantic-core

2368 serialization: Custom serialization schema

2369 """

2370 if field_name is not None:

2371 warnings.warn(

2372 'The `field_name` argument on `with_info_wrap_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',

2373 DeprecationWarning,

2374 stacklevel=2,

2375 )

2376

2377 return _dict_not_none(

2378 type='function-wrap',

2379 function=_dict_not_none(type='with-info', function=function, field_name=field_name),

2380 schema=schema,

2381 json_schema_input_schema=json_schema_input_schema,

2382 ref=ref,

2383 metadata=metadata,

2384 serialization=serialization,

2385 )

2386

2387

2388class PlainValidatorFunctionSchema(TypedDict, total=False):

2389 type: Required[Literal['function-plain']]

2390 function: Required[ValidationFunction]

2391 ref: str

2392 json_schema_input_schema: CoreSchema

2393 metadata: dict[str, Any]

2394 serialization: SerSchema

2395

2396

2397def no_info_plain_validator_function(

2398 function: NoInfoValidatorFunction,

2399 *,

2400 ref: str | None = None,

2401 json_schema_input_schema: CoreSchema | None = None,

2402 metadata: dict[str, Any] | None = None,

2403 serialization: SerSchema | None = None,

2404) -> PlainValidatorFunctionSchema:

2405 """

2406 Returns a schema that uses the provided function for validation, no `info` argument is passed, e.g.:

2407

2408 ```py

2409 from pydantic_core import SchemaValidator, core_schema

2410

2411 def fn(v: str) -> str:

2412 assert 'hello' in v

2413 return v + 'world'

2414

2415 schema = core_schema.no_info_plain_validator_function(function=fn)

2416 v = SchemaValidator(schema)

2417 assert v.validate_python('hello ') == 'hello world'

2418 ```

2419

2420 Args:

2421 function: The validator function to call

2422 ref: optional unique identifier of the schema, used to reference the schema in other places

2423 json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type

2424 metadata: Any other information you want to include with the schema, not used by pydantic-core

2425 serialization: Custom serialization schema

2426 """

2427 return _dict_not_none(

2428 type='function-plain',

2429 function={'type': 'no-info', 'function': function},

2430 ref=ref,

2431 json_schema_input_schema=json_schema_input_schema,

2432 metadata=metadata,

2433 serialization=serialization,

2434 )

2435

2436

2437def with_info_plain_validator_function(

2438 function: WithInfoValidatorFunction,

2439 *,

2440 field_name: str | None = None,

2441 ref: str | None = None,

2442 json_schema_input_schema: CoreSchema | None = None,

2443 metadata: dict[str, Any] | None = None,

2444 serialization: SerSchema | None = None,

2445) -> PlainValidatorFunctionSchema:

2446 """

2447 Returns a schema that uses the provided function for validation, an `info` argument is passed, e.g.:

2448

2449 ```py

2450 from pydantic_core import SchemaValidator, core_schema

2451

2452 def fn(v: str, info: core_schema.ValidationInfo) -> str:

2453 assert 'hello' in v

2454 return v + 'world'

2455

2456 schema = core_schema.with_info_plain_validator_function(function=fn)

2457 v = SchemaValidator(schema)

2458 assert v.validate_python('hello ') == 'hello world'

2459 ```

2460

2461 Args:

2462 function: The validator function to call

2463 field_name: The name of the field this validator is applied to, if any (deprecated)

2464 ref: optional unique identifier of the schema, used to reference the schema in other places

2465 json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type

2466 metadata: Any other information you want to include with the schema, not used by pydantic-core

2467 serialization: Custom serialization schema

2468 """

2469 if field_name is not None:

2470 warnings.warn(

2471 'The `field_name` argument on `with_info_plain_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',

2472 DeprecationWarning,

2473 stacklevel=2,

2474 )

2475

2476 return _dict_not_none(

2477 type='function-plain',

2478 function=_dict_not_none(type='with-info', function=function, field_name=field_name),