Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/pydantic/fields.py: 61%

1"""Defining fields on models.""" 

2 

3from __future__ import annotations as _annotations 

4 

5import dataclasses 

6import inspect 

7import re 

8import sys 

9from collections.abc import Callable, Mapping 

10from copy import copy 

11from dataclasses import Field as DataclassField 

12from functools import cached_property 

13from types import EllipsisType 

14from typing import TYPE_CHECKING, Annotated, Any, ClassVar, Literal, TypeAlias, TypeVar, final, overload 

15from warnings import warn 

16 

17import annotated_types 

18import typing_extensions 

19from pydantic_core import MISSING, PydanticUndefined 

20from typing_extensions import Self, TypedDict, TypeForm, Unpack, deprecated 

21from typing_inspection import typing_objects 

22from typing_inspection.introspection import UNKNOWN, AnnotationSource, ForbiddenQualifier, Qualifier, inspect_annotation 

23 

24from . import types 

25from ._internal import _decorators, _fields, _generics, _repr, _typing_extra, _utils 

26from ._internal._namespace_utils import GlobalsNamespace, MappingNamespace 

27from .aliases import AliasChoices, AliasGenerator, AliasPath 

28from .config import JsonDict 

29from .errors import PydanticForbiddenQualifier, PydanticUserError 

30from .json_schema import PydanticJsonSchemaWarning 

31from .warnings import PydanticDeprecatedSince20 

32 

33if TYPE_CHECKING: 

34 from ._internal._config import ConfigWrapper 

35 from ._internal._repr import ReprArgs 

36 

37 

38__all__ = 'Field', 'FieldInfo', 'PrivateAttr', 'computed_field' 

39 

40 

41_Unset: Any = PydanticUndefined 

42 

43if sys.version_info >= (3, 13): 

44 import warnings 

45 

46 Deprecated: TypeAlias = warnings.deprecated | deprecated 

47else: 

48 Deprecated: TypeAlias = deprecated 

49 

50 

51class _FromFieldInfoInputs(TypedDict, total=False): 

52 """This class exists solely to add type checking for the `**kwargs` in `FieldInfo.from_field`.""" 

53 

54 annotation: TypeForm[Any] 

55 default_factory: Callable[[], Any] | Callable[[dict[str, Any]], Any] | None 

56 alias: str | None 

57 alias_priority: int | None 

58 validation_alias: str | AliasPath | AliasChoices | None 

59 serialization_alias: str | None 

60 title: str | None 

61 field_title_generator: Callable[[str, FieldInfo], str] | None 

62 description: str | None 

63 examples: list[Any] | None 

64 exclude: bool | None 

65 exclude_if: Callable[[Any], bool] | None 

66 gt: annotated_types.SupportsGt | None 

67 ge: annotated_types.SupportsGe | None 

68 lt: annotated_types.SupportsLt | None 

69 le: annotated_types.SupportsLe | None 

70 multiple_of: float | None 

71 strict: bool | None 

72 min_length: int | None 

73 max_length: int | None 

74 pattern: str | re.Pattern[str] | None 

75 allow_inf_nan: bool | None 

76 max_digits: int | None 

77 decimal_places: int | None 

78 union_mode: Literal['smart', 'left_to_right'] | None 

79 discriminator: str | types.Discriminator | None 

80 deprecated: Deprecated | str | bool | None 

81 json_schema_extra: JsonDict | Callable[[JsonDict], None] | None 

82 frozen: bool | None 

83 validate_default: bool | None 

84 repr: bool 

85 init: bool | None 

86 init_var: bool | None 

87 kw_only: bool | None 

88 coerce_numbers_to_str: bool | None 

89 fail_fast: bool | None 

90 

91 

92class _FieldInfoAsDict(TypedDict, closed=True): 

93 annotation: TypeForm[Any] | None 

94 metadata: list[Any] 

95 attributes: dict[str, Any] 

96 

97 

98@final 

99class FieldInfo(_repr.Representation): 

100 """This class holds information about a field. 

101 

102 `FieldInfo` is used for any field definition regardless of whether the [`Field()`][pydantic.fields.Field] 

103 function is explicitly used. 

104 

105 !!! warning 

106 The `FieldInfo` class is meant to expose information about a field in a Pydantic model or dataclass. 

107 `FieldInfo` instances shouldn't be instantiated directly, nor mutated. 

108 

109 If you need to derive a new model from another one and are willing to alter `FieldInfo` instances, 

110 refer to this [dynamic model example](../examples/dynamic_models.md). 

111 

112 Attributes: 

113 annotation: The type annotation of the field. 

114 default: The default value of the field. 

115 default_factory: A callable to generate the default value. The callable can either take 0 arguments 

116 (in which case it is called as is) or a single argument containing the already validated data. 

117 alias: The alias name of the field. 

118 alias_priority: The priority of the field's alias. 

119 validation_alias: The validation alias of the field. 

120 serialization_alias: The serialization alias of the field. 

121 title: The title of the field. 

122 field_title_generator: A callable that takes a field's name and info and returns title for it. 

123 description: The description of the field. 

124 examples: List of examples of the field. 

125 exclude: Whether to exclude the field from the model serialization. 

126 exclude_if: A callable that determines whether to exclude a field during serialization based on its value. 

127 discriminator: Field name or Discriminator for discriminating the type in a tagged union. 

128 deprecated: A deprecation message, an instance of `warnings.deprecated` or the `typing_extensions.deprecated` backport, 

129 or a boolean. If `True`, a default deprecation message will be emitted when accessing the field. 

130 json_schema_extra: A dict or callable to provide extra JSON schema properties. 

131 frozen: Whether the field is frozen. 

132 validate_default: Whether to validate the default value of the field. 

133 repr: Whether to include the field in representation of the model. 

134 init: Whether the field should be included in the constructor of the dataclass. 

135 init_var: Whether the field should _only_ be included in the constructor of the dataclass, and not stored. 

136 kw_only: Whether the field should be a keyword-only argument in the constructor of the dataclass. 

137 metadata: The metadata list. Contains all the data that isn't expressed as direct `FieldInfo` attributes, including: 

138 

139 * Type-specific constraints, such as `gt` or `min_length` (these are converted to metadata classes such as `annotated_types.Gt`). 

140 * Any other arbitrary object used within [`Annotated`][typing.Annotated] metadata 

141 (e.g. [custom types handlers](../concepts/types.md#as-an-annotation) or any object not recognized by Pydantic). 

142 """ 

143 

144 annotation: TypeForm[Any] | None 

145 default: Any 

146 default_factory: Callable[[], Any] | Callable[[dict[str, Any]], Any] | None 

147 alias: str | None 

148 alias_priority: int | None 

149 validation_alias: str | AliasPath | AliasChoices | None 

150 serialization_alias: str | None 

151 title: str | None 

152 field_title_generator: Callable[[str, FieldInfo], str] | None 

153 description: str | None 

154 examples: list[Any] | None 

155 exclude: bool | None 

156 exclude_if: Callable[[Any], bool] | None 

157 discriminator: str | types.Discriminator | None 

158 deprecated: Deprecated | str | bool | None 

159 json_schema_extra: JsonDict | Callable[[JsonDict], None] | None 

160 frozen: bool | None 

161 validate_default: bool | None 

162 repr: bool 

163 init: bool | None 

164 init_var: bool | None 

165 kw_only: bool | None 

166 metadata: list[Any] 

167 

168 __slots__ = ( 

169 'annotation', 

170 'default', 

171 'default_factory', 

172 'alias', 

173 'alias_priority', 

174 'validation_alias', 

175 'serialization_alias', 

176 'title', 

177 'field_title_generator', 

178 'description', 

179 'examples', 

180 'exclude', 

181 'exclude_if', 

182 'discriminator', 

183 'deprecated', 

184 'json_schema_extra', 

185 'frozen', 

186 'validate_default', 

187 'repr', 

188 'init', 

189 'init_var', 

190 'kw_only', 

191 'metadata', 

192 '_attributes_set', 

193 '_qualifiers', 

194 '_complete', 

195 '_original_assignment', 

196 '_original_annotation', 

197 '_final', 

198 ) 

199 

200 # used to convert kwargs to metadata/constraints, 

201 # None has a special meaning - these items are collected into a `PydanticGeneralMetadata` 

202 metadata_lookup: ClassVar[dict[str, Callable[[Any], Any] | None]] = { 

203 'strict': types.Strict, 

204 'gt': annotated_types.Gt, 

205 'ge': annotated_types.Ge, 

206 'lt': annotated_types.Lt, 

207 'le': annotated_types.Le, 

208 'multiple_of': annotated_types.MultipleOf, 

209 'min_length': annotated_types.MinLen, 

210 'max_length': annotated_types.MaxLen, 

211 'pattern': None, 

212 'allow_inf_nan': types.AllowInfNan, 

213 'max_digits': None, 

214 'decimal_places': None, 

215 'union_mode': None, 

216 'coerce_numbers_to_str': None, 

217 'fail_fast': types.FailFast, 

218 } 

219 

220 def __init__( 

221 self, 

222 *, 

223 annotation: TypeForm[Any] | None = _Unset, 

224 default: Any = _Unset, 

225 default_factory: Callable[[], Any] | Callable[[dict[str, Any]], Any] | None = _Unset, 

226 alias: str | None = _Unset, 

227 alias_priority: int | None = _Unset, 

228 validation_alias: str | AliasPath | AliasChoices | None = _Unset, 

229 serialization_alias: str | None = _Unset, 

230 title: str | None = _Unset, 

231 field_title_generator: Callable[[str, FieldInfo], str] | None = _Unset, 

232 description: str | None = _Unset, 

233 examples: list[Any] | None = _Unset, 

234 exclude: bool | None = _Unset, 

235 exclude_if: Callable[[Any], bool] | None = _Unset, 

236 discriminator: str | types.Discriminator | None = _Unset, 

237 deprecated: Deprecated | str | bool | None = _Unset, 

238 json_schema_extra: JsonDict | Callable[[JsonDict], None] | None = _Unset, 

239 frozen: bool | None = _Unset, 

240 validate_default: bool | None = _Unset, 

241 repr: bool = _Unset, 

242 init: bool | None = _Unset, 

243 init_var: bool | None = _Unset, 

244 kw_only: bool | None = _Unset, 

245 # The following arguments are converted to metadata (see `_collect_metadata()`), in the order `Field()` forwards them: 

246 pattern: str | re.Pattern[str] | None = _Unset, 

247 coerce_numbers_to_str: bool | None = _Unset, 

248 strict: bool | None = _Unset, 

249 gt: annotated_types.SupportsGt | None = _Unset, 

250 ge: annotated_types.SupportsGe | None = _Unset, 

251 lt: annotated_types.SupportsLt | None = _Unset, 

252 le: annotated_types.SupportsLe | None = _Unset, 

253 multiple_of: float | None = _Unset, 

254 min_length: int | None = _Unset, 

255 max_length: int | None = _Unset, 

256 allow_inf_nan: bool | None = _Unset, 

257 max_digits: int | None = _Unset, 

258 decimal_places: int | None = _Unset, 

259 union_mode: Literal['smart', 'left_to_right'] | None = _Unset, 

260 fail_fast: bool | None = _Unset, 

261 **kwargs: Any, 

262 ) -> None: 

263 """This class should generally not be initialized directly; instead, use the `pydantic.fields.Field` function 

264 or one of the constructor classmethods. 

265 

266 See the signature of `pydantic.fields.Field` for more details about the expected arguments. 

267 Unknown keyword arguments are accepted (and ignored) for backwards compatibility. 

268 """ 

269 # Tracking the explicitly set attributes is necessary to correctly merge `Field()` functions 

270 # (e.g. with `Annotated[int, Field(alias='a'), Field(alias=None)]`, even though `None` is the default value, 

271 # we need to track that `alias=None` was explicitly set): 

272 self._attributes_set = attributes_set = {} 

273 

274 if annotation is _Unset: 

275 annotation = None 

276 else: 

277 attributes_set['annotation'] = annotation 

278 self.annotation = annotation 

279 

280 if default is _Unset or default is Ellipsis: 

281 default = PydanticUndefined 

282 else: 

283 attributes_set['default'] = default 

284 self.default = default 

285 

286 if default_factory is _Unset: 

287 default_factory = None 

288 else: 

289 attributes_set['default_factory'] = default_factory 

290 self.default_factory = default_factory 

291 

292 if default is not PydanticUndefined and default_factory is not None: 

293 raise TypeError('cannot specify both default and default_factory') 

294 

295 if alias is _Unset: 

296 alias = None 

297 else: 

298 attributes_set['alias'] = alias 

299 self.alias = alias 

300 

301 if alias_priority is _Unset: 

302 alias_priority = None 

303 else: 

304 attributes_set['alias_priority'] = alias_priority 

305 

306 if validation_alias is _Unset: 

307 validation_alias = None 

308 else: 

309 attributes_set['validation_alias'] = validation_alias 

310 self.validation_alias = validation_alias 

311 

312 if serialization_alias is _Unset: 

313 serialization_alias = None 

314 else: 

315 attributes_set['serialization_alias'] = serialization_alias 

316 self.serialization_alias = serialization_alias 

317 

318 alias_is_set = alias is not None or validation_alias is not None or serialization_alias is not None 

319 self.alias_priority = (alias_priority or 2) if alias_is_set else None 

320 

321 if title is _Unset: 

322 title = None 

323 else: 

324 attributes_set['title'] = title 

325 self.title = title 

326 

327 if field_title_generator is _Unset: 

328 field_title_generator = None 

329 else: 

330 attributes_set['field_title_generator'] = field_title_generator 

331 self.field_title_generator = field_title_generator 

332 

333 if description is _Unset: 

334 description = None 

335 else: 

336 attributes_set['description'] = description 

337 self.description = description 

338 

339 if examples is _Unset: 

340 examples = None 

341 else: 

342 attributes_set['examples'] = examples 

343 self.examples = examples 

344 

345 if exclude is _Unset: 

346 exclude = None 

347 else: 

348 attributes_set['exclude'] = exclude 

349 self.exclude = exclude 

350 

351 if exclude_if is _Unset: 

352 exclude_if = None 

353 else: 

354 attributes_set['exclude_if'] = exclude_if 

355 self.exclude_if = exclude_if 

356 

357 if discriminator is _Unset: 

358 discriminator = None 

359 else: 

360 attributes_set['discriminator'] = discriminator 

361 self.discriminator = discriminator 

362 

363 if deprecated is _Unset: 

364 # For compatibility with FastAPI<=0.110.0, we preserve the existing value if it is not overridden 

365 deprecated = getattr(self, 'deprecated', None) 

366 else: 

367 attributes_set['deprecated'] = deprecated 

368 self.deprecated = deprecated 

369 

370 if repr is _Unset: 

371 repr = True 

372 else: 

373 attributes_set['repr'] = repr 

374 self.repr = repr 

375 

376 if json_schema_extra is _Unset: 

377 json_schema_extra = None 

378 else: 

379 attributes_set['json_schema_extra'] = json_schema_extra 

380 self.json_schema_extra = json_schema_extra 

381 

382 if validate_default is _Unset: 

383 validate_default = None 

384 else: 

385 attributes_set['validate_default'] = validate_default 

386 self.validate_default = validate_default 

387 

388 if frozen is _Unset: 

389 frozen = None 

390 else: 

391 attributes_set['frozen'] = frozen 

392 self.frozen = frozen 

393 

394 # currently only used on dataclasses 

395 if init is _Unset: 

396 init = None 

397 else: 

398 attributes_set['init'] = init 

399 self.init = init 

400 

401 if init_var is _Unset: 

402 init_var = None 

403 else: 

404 attributes_set['init_var'] = init_var 

405 self.init_var = init_var 

406 

407 if kw_only is _Unset: 

408 kw_only = None 

409 else: 

410 attributes_set['kw_only'] = kw_only 

411 self.kw_only = kw_only 

412 

413 # (in the order `Field()` forwards them, which determines the order of the metadata) 

414 metadata_kwargs: dict[str, Any] = {} 

415 if pattern is not _Unset: 

416 metadata_kwargs['pattern'] = pattern 

417 if coerce_numbers_to_str is not _Unset: 

418 metadata_kwargs['coerce_numbers_to_str'] = coerce_numbers_to_str 

419 if strict is not _Unset: 

420 metadata_kwargs['strict'] = strict 

421 if gt is not _Unset: 

422 metadata_kwargs['gt'] = gt 

423 if ge is not _Unset: 

424 metadata_kwargs['ge'] = ge 

425 if lt is not _Unset: 

426 metadata_kwargs['lt'] = lt 

427 if le is not _Unset: 

428 metadata_kwargs['le'] = le 

429 if multiple_of is not _Unset: 

430 metadata_kwargs['multiple_of'] = multiple_of 

431 if min_length is not _Unset: 

432 metadata_kwargs['min_length'] = min_length 

433 if max_length is not _Unset: 

434 metadata_kwargs['max_length'] = max_length 

435 if allow_inf_nan is not _Unset: 

436 metadata_kwargs['allow_inf_nan'] = allow_inf_nan 

437 if max_digits is not _Unset: 

438 metadata_kwargs['max_digits'] = max_digits 

439 if decimal_places is not _Unset: 

440 metadata_kwargs['decimal_places'] = decimal_places 

441 if union_mode is not _Unset: 

442 metadata_kwargs['union_mode'] = union_mode 

443 if fail_fast is not _Unset: 

444 metadata_kwargs['fail_fast'] = fail_fast 

445 self.metadata = self._collect_metadata(metadata_kwargs) if metadata_kwargs else [] 

446 

447 if kwargs: 

448 # Unknown keyword arguments (kept for backwards compatibility): 

449 attributes_set.update({key: value for key, value in kwargs.items() if value is not _Unset}) 

450 

451 # Private attributes: 

452 self._qualifiers: set[Qualifier] = set() 

453 # Used to rebuild FieldInfo instances: 

454 self._complete = True 

455 self._original_annotation: Any = PydanticUndefined 

456 self._original_assignment: Any = PydanticUndefined 

457 # Used to track whether the `FieldInfo` instance represents the data about a field (and is exposed in `model_fields`/`__pydantic_fields__`), 

458 # or if it is the result of the `Field()` function being used as metadata in an `Annotated` type/as an assignment 

459 # (not an ideal pattern, see https://github.com/pydantic/pydantic/issues/11122): 

460 self._final = False 

461 

462 @staticmethod 

463 def from_field(default: Any = PydanticUndefined, **kwargs: Unpack[_FromFieldInfoInputs]) -> FieldInfo: 

464 """Create a new `FieldInfo` object with the `Field` function. 

465 

466 Args: 

467 default: The default value for the field. Defaults to Undefined. 

468 **kwargs: Additional arguments dictionary. 

469 

470 Raises: 

471 TypeError: If 'annotation' is passed as a keyword argument. 

472 

473 Returns: 

474 A new FieldInfo object with the given parameters. 

475 

476 Example: 

477 This is how you can create a field with default value like this: 

478 

479 ```python 

480 import pydantic 

481 

482 class MyModel(pydantic.BaseModel): 

483 foo: int = pydantic.Field(4) 

484 ``` 

485 """ 

486 if 'annotation' in kwargs: 

487 raise TypeError('"annotation" is not permitted as a Field keyword argument') 

488 return FieldInfo(default=default, **kwargs) 

489 

490 @staticmethod 

491 def from_annotation(annotation: type[Any], *, _source: AnnotationSource = AnnotationSource.ANY) -> FieldInfo: 

492 """Creates a `FieldInfo` instance from a bare annotation. 

493 

494 This function is used internally to create a `FieldInfo` from a bare annotation like this: 

495 

496 ```python 

497 import pydantic 

498 

499 class MyModel(pydantic.BaseModel): 

500 foo: int # <-- like this 

501 ``` 

502 

503 We also account for the case where the annotation can be an instance of `Annotated` and where 

504 one of the (not first) arguments in `Annotated` is an instance of `FieldInfo`, e.g.: 

505 

506 ```python 

507 from typing import Annotated 

508 

509 import annotated_types 

510 

511 import pydantic 

512 

513 class MyModel(pydantic.BaseModel): 

514 foo: Annotated[int, annotated_types.Gt(42)] 

515 bar: Annotated[int, pydantic.Field(gt=42)] 

516 ``` 

517 

518 Args: 

519 annotation: An annotation object. 

520 

521 Returns: 

522 An instance of the field metadata. 

523 """ 

524 try: 

525 inspected_ann = inspect_annotation( 

526 annotation, 

527 annotation_source=_source, 

528 unpack_type_aliases='skip', 

529 ) 

530 except ForbiddenQualifier as e: 

531 raise PydanticForbiddenQualifier(e.qualifier, annotation) 

532 

533 # TODO check for classvar and error? 

534 

535 # No assigned value, this happens when using a bare `Final` qualifier (also for other 

536 # qualifiers, but they shouldn't appear here). In this case we infer the type as `Any` 

537 # because we don't have any assigned value. 

538 type_expr: Any = Any if inspected_ann.type is UNKNOWN else inspected_ann.type 

539 final = 'final' in inspected_ann.qualifiers 

540 metadata = inspected_ann.metadata 

541 

542 attr_overrides = {'annotation': type_expr} 

543 if final: 

544 attr_overrides['frozen'] = True 

545 field_info = FieldInfo._construct(metadata, **attr_overrides) 

546 field_info._qualifiers = inspected_ann.qualifiers 

547 field_info._final = True 

548 return field_info 

549 

550 @staticmethod 

551 def from_annotated_attribute( 

552 annotation: type[Any], default: Any, *, _source: AnnotationSource = AnnotationSource.ANY 

553 ) -> FieldInfo: 

554 """Create `FieldInfo` from an annotation with a default value. 

555 

556 This is used in cases like the following: 

557 

558 ```python 

559 from typing import Annotated 

560 

561 import annotated_types 

562 

563 import pydantic 

564 

565 class MyModel(pydantic.BaseModel): 

566 foo: int = 4 # <-- like this 

567 bar: Annotated[int, annotated_types.Gt(4)] = 4 # <-- or this 

568 spam: Annotated[int, pydantic.Field(gt=4)] = 4 # <-- or this 

569 ``` 

570 

571 Args: 

572 annotation: The type annotation of the field. 

573 default: The default value of the field. 

574 

575 Returns: 

576 A field object with the passed values. 

577 """ 

578 if annotation is not MISSING and annotation is default: 

579 raise PydanticUserError( 

580 'Error when building FieldInfo from annotated attribute. ' 

581 "Make sure you don't have any field name clashing with a type annotation.", 

582 code='unevaluable-type-annotation', 

583 ) 

584 

585 try: 

586 inspected_ann = inspect_annotation( 

587 annotation, 

588 annotation_source=_source, 

589 unpack_type_aliases='skip', 

590 ) 

591 except ForbiddenQualifier as e: 

592 raise PydanticForbiddenQualifier(e.qualifier, annotation) 

593 

594 # TODO check for classvar and error? 

595 

596 # TODO infer from the default, this can be done in v3 once we treat final fields with 

597 # a default as proper fields and not class variables: 

598 type_expr: Any = Any if inspected_ann.type is UNKNOWN else inspected_ann.type 

599 final = 'final' in inspected_ann.qualifiers 

600 metadata = inspected_ann.metadata 

601 

602 # HACK 1: the order in which the metadata is merged is inconsistent; we need to prepend 

603 # metadata from the assignment at the beginning of the metadata. Changing this is only 

604 # possible in v3 (at least). See https://github.com/pydantic/pydantic/issues/10507 

605 prepend_metadata: list[Any] | None = None 

606 attr_overrides = {'annotation': type_expr} 

607 if final: 

608 attr_overrides['frozen'] = True 

609 

610 # HACK 2: FastAPI is subclassing `FieldInfo` and historically expected the actual 

611 # instance's type to be preserved when constructing new models with its subclasses as assignments. 

612 # This code is never reached by Pydantic itself, and in an ideal world this shouldn't be necessary. 

613 if not metadata and isinstance(default, FieldInfo) and type(default) is not FieldInfo: 

614 field_info = default._copy() 

615 field_info._attributes_set.update(attr_overrides) 

616 for k, v in attr_overrides.items(): 

617 setattr(field_info, k, v) 

618 return field_info 

619 

620 if isinstance(default, FieldInfo): 

621 default_copy = default._copy() # Copy unnecessary when we remove HACK 1. 

622 prepend_metadata = default_copy.metadata 

623 default_copy.metadata = [] 

624 metadata = metadata + [default_copy] 

625 if 'init_var' in inspected_ann.qualifiers: 

626 # Only relevant for dataclasses, when `f: InitVar[<type>] = Field(...)` 

627 # is used: 

628 attr_overrides['init_var'] = True 

629 elif isinstance(default, dataclasses.Field): 

630 from_field = FieldInfo._from_dataclass_field(default) 

631 prepend_metadata = from_field.metadata # Unnecessary when we remove HACK 1. 

632 from_field.metadata = [] 

633 metadata = metadata + [from_field] 

634 if 'init_var' in inspected_ann.qualifiers: 

635 attr_overrides['init_var'] = True 

636 if (init := getattr(default, 'init', None)) is not None: 

637 attr_overrides['init'] = init 

638 if (kw_only := getattr(default, 'kw_only', None)) is not None: 

639 attr_overrides['kw_only'] = kw_only 

640 else: 

641 # `default` is the actual default value 

642 attr_overrides['default'] = default 

643 

644 field_info = FieldInfo._construct( 

645 prepend_metadata + metadata if prepend_metadata is not None else metadata, **attr_overrides 

646 ) 

647 field_info._qualifiers = inspected_ann.qualifiers 

648 field_info._final = True 

649 return field_info 

650 

651 @classmethod 

652 def _construct(cls, metadata: list[Any], **attr_overrides: Any) -> Self: 

653 """Construct the final `FieldInfo` instance, by merging the possibly existing `FieldInfo` instances from the metadata. 

654 

655 With the following example: 

656 

657 ```python {test="skip" lint="skip"} 

658 class Model(BaseModel): 

659 f: Annotated[int, Gt(1), Field(description='desc', lt=2)] 

660 ``` 

661 

662 `metadata` refers to the metadata elements of the `Annotated` form. This metadata is iterated over from left to right: 

663 

664 - If the element is a `Field()` function (which is itself a `FieldInfo` instance), the field attributes (such as 

665 `description`) are saved to be set on the final `FieldInfo` instance. 

666 On the other hand, some kwargs (such as `lt`) are stored as `metadata` (see `FieldInfo.__init__()`, calling 

667 `FieldInfo._collect_metadata()`). In this case, the final metadata list is extended with the one from this instance. 

668 - Else, the element is considered as a single metadata object, and is appended to the final metadata list. 

669 

670 Args: 

671 metadata: The list of metadata elements to merge together. If the `FieldInfo` instance to be constructed is for 

672 a field with an assigned `Field()`, this `Field()` assignment should be added as the last element of the 

673 provided metadata. 

674 **attr_overrides: Extra attributes that should be set on the final merged `FieldInfo` instance. 

675 

676 Returns: 

677 The final merged `FieldInfo` instance. 

678 """ 

679 merged_metadata: list[Any] = [] 

680 merged_kwargs: dict[str, Any] = {} 

681 

682 for meta in metadata: 

683 if isinstance(meta, FieldInfo): 

684 merged_metadata.extend(meta.metadata) 

685 

686 new_js_extra: JsonDict | None = None 

687 current_js_extra = meta.json_schema_extra 

688 if current_js_extra is not None and 'json_schema_extra' in merged_kwargs: 

689 # We need to merge `json_schema_extra`'s: 

690 existing_js_extra = merged_kwargs['json_schema_extra'] 

691 if isinstance(existing_js_extra, dict): 

692 if isinstance(current_js_extra, dict): 

693 new_js_extra = { 

694 **existing_js_extra, 

695 **current_js_extra, 

696 } 

697 elif callable(current_js_extra): 

698 # The `callable` is ignored, so we keep the existing `dict`. This needs to be set 

699 # explicitly as `merged_kwargs` is otherwise overridden with `meta._attributes_set` 

700 # (which contains the `callable`) below. 

701 new_js_extra = existing_js_extra 

702 warn( 

703 'Composing `dict` and `callable` type `json_schema_extra` is not supported. ' 

704 'The `callable` type is being ignored. ' 

705 "If you'd like support for this behavior, please open an issue on pydantic.", 

706 UserWarning, 

707 ) 

708 elif callable(existing_js_extra) and isinstance(current_js_extra, dict): 

709 warn( 

710 'Composing `dict` and `callable` type `json_schema_extra` is not supported. ' 

711 'The `callable` type is being ignored. ' 

712 "If you'd like support for this behavior, please open an issue on pydantic.", 

713 UserWarning, 

714 ) 

715 

716 # HACK: It is common for users to define "make model partial" (or similar) utilities, that 

717 # convert all model fields to be optional (i.e. have a default value). To do so, they mutate 

718 # each `FieldInfo` instance from `model_fields` to set a `default`, and use `create_model()` 

719 # with `Annotated[<orig_type> | None, mutated_field_info]`` as an annotation. However, such 

720 # mutations (by doing simple assignments) are only accidentally working, because we also 

721 # need to track attributes explicitly set in `_attributes_set` (relying on default values for 

722 # each attribute is *not* enough, for instance with `Annotated[int, Field(alias='a'), Field(alias=None)]` 

723 # the resulting `FieldInfo` should have `alias=None`). 

724 # To mitigate this, we add a special case when a "final" `FieldInfo` instance (that is an instance coming 

725 # from `model_fields`) is used in annotated metadata (or assignment). In this case, we assume *all* attributes 

726 # were explicitly set, and as such we use all of them (and this will correctly pick up the mutations). 

727 # In theory, this shouldn't really be supported, you are only supposed to use the `Field()` function, not 

728 # a `FieldInfo` instance directly (granted, `Field()` returns a `FieldInfo`, see 

729 # https://github.com/pydantic/pydantic/issues/11122): 

730 if meta._final: 

731 merged_kwargs.update({attr: getattr(meta, attr) for attr in _Attrs}) 

732 else: 

733 merged_kwargs.update(meta._attributes_set) 

734 

735 if new_js_extra is not None: 

736 merged_kwargs['json_schema_extra'] = new_js_extra 

737 elif typing_objects.is_deprecated(meta): 

738 merged_kwargs['deprecated'] = meta 

739 else: 

740 merged_metadata.append(meta) 

741 

742 merged_kwargs.update(attr_overrides) 

743 merged_field_info = cls(**merged_kwargs) 

744 merged_field_info.metadata = merged_metadata 

745 return merged_field_info 

746 

747 @staticmethod 

748 @typing_extensions.deprecated( 

749 "The 'merge_field_infos()' method is deprecated and will be removed in a future version. " 

750 'If you relied on this method, please open an issue in the Pydantic issue tracker.', 

751 category=None, 

752 ) 

753 def merge_field_infos(*field_infos: FieldInfo, **overrides: Any) -> FieldInfo: 

754 """Merge `FieldInfo` instances keeping only explicitly set attributes. 

755 

756 Later `FieldInfo` instances override earlier ones. 

757 

758 Returns: 

759 FieldInfo: A merged FieldInfo instance. 

760 """ 

761 if len(field_infos) == 1: 

762 # No merging necessary, but we still need to make a copy and apply the overrides 

763 field_info = field_infos[0]._copy() 

764 field_info._attributes_set.update(overrides) 

765 

766 default_override = overrides.pop('default', PydanticUndefined) 

767 if default_override is Ellipsis: 

768 default_override = PydanticUndefined 

769 if default_override is not PydanticUndefined: 

770 field_info.default = default_override 

771 

772 for k, v in overrides.items(): 

773 setattr(field_info, k, v) 

774 return field_info # type: ignore 

775 

776 merged_field_info_kwargs: dict[str, Any] = {} 

777 metadata = {} 

778 for field_info in field_infos: 

779 attributes_set = field_info._attributes_set.copy() 

780 

781 try: 

782 json_schema_extra = attributes_set.pop('json_schema_extra') 

783 existing_json_schema_extra = merged_field_info_kwargs.get('json_schema_extra') 

784 

785 if existing_json_schema_extra is None: 

786 merged_field_info_kwargs['json_schema_extra'] = json_schema_extra 

787 if isinstance(existing_json_schema_extra, dict): 

788 if isinstance(json_schema_extra, dict): 

789 merged_field_info_kwargs['json_schema_extra'] = { 

790 **existing_json_schema_extra, 

791 **json_schema_extra, 

792 } 

793 if callable(json_schema_extra): 

794 warn( 

795 'Composing `dict` and `callable` type `json_schema_extra` is not supported.' 

796 'The `callable` type is being ignored.' 

797 "If you'd like support for this behavior, please open an issue on pydantic.", 

798 PydanticJsonSchemaWarning, 

799 ) 

800 elif callable(json_schema_extra): 

801 # if ever there's a case of a callable, we'll just keep the last json schema extra spec 

802 merged_field_info_kwargs['json_schema_extra'] = json_schema_extra 

803 except KeyError: 

804 pass 

805 

806 # later FieldInfo instances override everything except json_schema_extra from earlier FieldInfo instances 

807 merged_field_info_kwargs.update(attributes_set) 

808 

809 for x in field_info.metadata: 

810 if not isinstance(x, FieldInfo): 

811 metadata[type(x)] = x 

812 

813 merged_field_info_kwargs.update(overrides) 

814 field_info = FieldInfo(**merged_field_info_kwargs) 

815 field_info.metadata = list(metadata.values()) 

816 return field_info 

817 

818 @staticmethod 

819 def _from_dataclass_field(dc_field: DataclassField[Any]) -> FieldInfo: 

820 """Return a new `FieldInfo` instance from a `dataclasses.Field` instance. 

821 

822 Args: 

823 dc_field: The `dataclasses.Field` instance to convert. 

824 

825 Returns: 

826 The corresponding `FieldInfo` instance. 

827 

828 Raises: 

829 TypeError: If any of the `FieldInfo` kwargs does not match the `dataclass.Field` kwargs. 

830 """ 

831 default = dc_field.default 

832 if default is dataclasses.MISSING: 

833 default = _Unset 

834 

835 if dc_field.default_factory is dataclasses.MISSING: 

836 default_factory = _Unset 

837 else: 

838 default_factory = dc_field.default_factory 

839 

840 # use the `Field` function so in correct kwargs raise the correct `TypeError` 

841 dc_field_metadata = {k: v for k, v in dc_field.metadata.items() if k in _FIELD_ARG_NAMES} 

842 if sys.version_info >= (3, 14) and dc_field.doc is not None: 

843 dc_field_metadata['description'] = dc_field.doc 

844 return Field(default=default, default_factory=default_factory, repr=dc_field.repr, **dc_field_metadata) # pyright: ignore[reportCallIssue] 

845 

846 @staticmethod 

847 def _collect_metadata(kwargs: dict[str, Any]) -> list[Any]: 

848 """Collect annotations from kwargs. 

849 

850 Args: 

851 kwargs: Keyword arguments passed to the function. 

852 

853 Returns: 

854 A list of metadata objects - a combination of `annotated_types.BaseMetadata` and 

855 `PydanticMetadata`. 

856 """ 

857 metadata: list[Any] = [] 

858 general_metadata = {} 

859 for key, value in list(kwargs.items()): 

860 try: 

861 marker = FieldInfo.metadata_lookup[key] 

862 except KeyError: 

863 continue 

864 

865 del kwargs[key] 

866 if value is not None: 

867 if marker is None: 

868 general_metadata[key] = value 

869 else: 

870 metadata.append(marker(value)) 

871 if general_metadata: 

872 metadata.append(_fields.pydantic_general_metadata(**general_metadata)) 

873 return metadata 

874 

875 @property 

876 def deprecation_message(self) -> str | None: 

877 """The deprecation message to be emitted, or `None` if not set.""" 

878 if self.deprecated is None: 

879 return None 

880 if isinstance(self.deprecated, bool): 

881 return 'deprecated' if self.deprecated else None 

882 return self.deprecated if isinstance(self.deprecated, str) else self.deprecated.message