Coverage for pydantic/main.py: 98.10%
550 statements
« prev ^ index » next coverage.py v7.9.1, created at 2025-06-14 08:39 +0000
1"""Logic for creating models."""
3# Because `dict` is in the local namespace of the `BaseModel` class, we use `Dict` for annotations.
4# TODO v3 fallback to `dict` when the deprecated `dict` method gets removed.
5# ruff: noqa: UP035
7from __future__ import annotations as _annotations 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
9import operator 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
10import sys 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
11import types 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
12import typing 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
13import warnings 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
14from collections.abc import Generator, Mapping 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
15from copy import copy, deepcopy 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
16from functools import cached_property 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
17from typing import ( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
18 TYPE_CHECKING,
19 Any,
20 Callable,
21 ClassVar,
22 Dict,
23 Literal,
24 TypeVar,
25 Union,
26 cast,
27 overload,
28)
30import pydantic_core 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
31import typing_extensions 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
32from pydantic_core import PydanticUndefined, ValidationError 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
33from typing_extensions import Self, TypeAlias, Unpack 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
35from . import PydanticDeprecatedSince20, PydanticDeprecatedSince211 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
36from ._internal import ( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
37 _config,
38 _decorators,
39 _fields,
40 _forward_ref,
41 _generics,
42 _mock_val_ser,
43 _model_construction,
44 _namespace_utils,
45 _repr,
46 _typing_extra,
47 _utils,
48)
49from ._migration import getattr_migration 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
50from .aliases import AliasChoices, AliasPath 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
51from .annotated_handlers import GetCoreSchemaHandler, GetJsonSchemaHandler 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
52from .config import ConfigDict 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
53from .errors import PydanticUndefinedAnnotation, PydanticUserError 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
54from .json_schema import DEFAULT_REF_TEMPLATE, GenerateJsonSchema, JsonSchemaMode, JsonSchemaValue, model_json_schema 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
55from .plugin._schema_validator import PluggableSchemaValidator 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
57if TYPE_CHECKING: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
58 from inspect import Signature
59 from pathlib import Path
61 from pydantic_core import CoreSchema, SchemaSerializer, SchemaValidator
63 from ._internal._namespace_utils import MappingNamespace
64 from ._internal._utils import AbstractSetIntStr, MappingIntStrAny
65 from .deprecated.parse import Protocol as DeprecatedParseProtocol
66 from .fields import ComputedFieldInfo, FieldInfo, ModelPrivateAttr 1r
67else:
68 # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915
69 # and https://youtrack.jetbrains.com/issue/PY-51428
70 DeprecationWarning = PydanticDeprecatedSince20 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
72__all__ = 'BaseModel', 'create_model' 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
74# Keep these type aliases available at runtime:
75TupleGenerator: TypeAlias = Generator[tuple[str, Any], None, None] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
76# NOTE: In reality, `bool` should be replaced by `Literal[True]` but mypy fails to correctly apply bidirectional
77# type inference (e.g. when using `{'a': {'b': True}}`):
78# NOTE: Keep this type alias in sync with the stub definition in `pydantic-core`:
79IncEx: TypeAlias = Union[set[int], set[str], Mapping[int, Union['IncEx', bool]], Mapping[str, Union['IncEx', bool]]] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
81_object_setattr = _model_construction.object_setattr 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
84def _check_frozen(model_cls: type[BaseModel], name: str, value: Any) -> None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
85 if model_cls.model_config.get('frozen'): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
86 error_type = 'frozen_instance' 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
87 elif getattr(model_cls.__pydantic_fields__.get(name), 'frozen', False): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
88 error_type = 'frozen_field' 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
89 else:
90 return 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
92 raise ValidationError.from_exception_data( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
93 model_cls.__name__, [{'type': error_type, 'loc': (name,), 'input': value}]
94 )
97def _model_field_setattr_handler(model: BaseModel, name: str, val: Any) -> None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
98 model.__dict__[name] = val 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
99 model.__pydantic_fields_set__.add(name) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
102def _private_setattr_handler(model: BaseModel, name: str, val: Any) -> None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
103 if getattr(model, '__pydantic_private__', None) is None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
104 # While the attribute should be present at this point, this may not be the case if
105 # users do unusual stuff with `model_post_init()` (which is where the `__pydantic_private__`
106 # is initialized, by wrapping the user-defined `model_post_init()`), e.g. if they mock
107 # the `model_post_init()` call. Ideally we should find a better way to init private attrs.
108 object.__setattr__(model, '__pydantic_private__', {}) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
109 model.__pydantic_private__[name] = val # pyright: ignore[reportOptionalSubscript] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
112_SIMPLE_SETATTR_HANDLERS: Mapping[str, Callable[[BaseModel, str, Any], None]] = { 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
113 'model_field': _model_field_setattr_handler,
114 'validate_assignment': lambda model, name, val: model.__pydantic_validator__.validate_assignment(model, name, val), # pyright: ignore[reportAssignmentType]
115 'private': _private_setattr_handler,
116 'cached_property': lambda model, name, val: model.__dict__.__setitem__(name, val),
117 'extra_known': lambda model, name, val: _object_setattr(model, name, val),
118}
121class BaseModel(metaclass=_model_construction.ModelMetaclass): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
122 """!!! abstract "Usage Documentation"
123 [Models](../concepts/models.md)
125 A base class for creating Pydantic models.
127 Attributes:
128 __class_vars__: The names of the class variables defined on the model.
129 __private_attributes__: Metadata about the private attributes of the model.
130 __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.
132 __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
133 __pydantic_core_schema__: The core schema of the model.
134 __pydantic_custom_init__: Whether the model has a custom `__init__` function.
135 __pydantic_decorators__: Metadata containing the decorators defined on the model.
136 This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
137 __pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
138 __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
139 __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
140 __pydantic_post_init__: The name of the post-init method for the model, if defined.
141 __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
142 __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
143 __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
145 __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
146 __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
148 __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
149 is set to `'allow'`.
150 __pydantic_fields_set__: The names of fields explicitly set during instantiation.
151 __pydantic_private__: Values of private attributes set on the model instance.
152 """
154 # Note: Many of the below class vars are defined in the metaclass, but we define them here for type checking purposes.
156 model_config: ClassVar[ConfigDict] = ConfigDict() 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
157 """ 1puqvcladerwxyzmnfghJsAtBiobjk
158 Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].
159 """
161 __class_vars__: ClassVar[set[str]] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
162 """The names of the class variables defined on the model.""" 1puqvcladerwxyzmnfghJsAtBiobjk
164 __private_attributes__: ClassVar[Dict[str, ModelPrivateAttr]] # noqa: UP006 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
165 """Metadata about the private attributes of the model.""" 1puqvcladerwxyzmnfghJsAtBiobjk
167 __signature__: ClassVar[Signature] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
168 """The synthesized `__init__` [`Signature`][inspect.Signature] of the model.""" 1puqvcladerwxyzmnfghJsAtBiobjk
170 __pydantic_complete__: ClassVar[bool] = False 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
171 """Whether model building is completed, or if there are still undefined fields.""" 1puqvcladerwxyzmnfghJsAtBiobjk
173 __pydantic_core_schema__: ClassVar[CoreSchema] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
174 """The core schema of the model.""" 1puqvcladerwxyzmnfghJsAtBiobjk
176 __pydantic_custom_init__: ClassVar[bool] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
177 """Whether the model has a custom `__init__` method.""" 1puqvcladerwxyzmnfghJsAtBiobjk
179 # Must be set for `GenerateSchema.model_schema` to work for a plain `BaseModel` annotation.
180 __pydantic_decorators__: ClassVar[_decorators.DecoratorInfos] = _decorators.DecoratorInfos() 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
181 """Metadata containing the decorators defined on the model. 1puqvcladerwxyzmnfghJsAtBiobjk
182 This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1."""
184 __pydantic_generic_metadata__: ClassVar[_generics.PydanticGenericMetadata] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
185 """Metadata for generic models; contains data used for a similar purpose to 1puqvcladerwxyzmnfghJsAtBiobjk
186 __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these."""
188 __pydantic_parent_namespace__: ClassVar[Dict[str, Any] | None] = None # noqa: UP006 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
189 """Parent namespace of the model, used for automatic rebuilding of models.""" 1puqvcladerwxyzmnfghJsAtBiobjk
191 __pydantic_post_init__: ClassVar[None | Literal['model_post_init']] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
192 """The name of the post-init method for the model, if defined.""" 1puqvcladerwxyzmnfghJsAtBiobjk
194 __pydantic_root_model__: ClassVar[bool] = False 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
195 """Whether the model is a [`RootModel`][pydantic.root_model.RootModel].""" 1puqvcladerwxyzmnfghJsAtBiobjk
197 __pydantic_serializer__: ClassVar[SchemaSerializer] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
198 """The `pydantic-core` `SchemaSerializer` used to dump instances of the model.""" 1puqvcladerwxyzmnfghJsAtBiobjk
200 __pydantic_validator__: ClassVar[SchemaValidator | PluggableSchemaValidator] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
201 """The `pydantic-core` `SchemaValidator` used to validate instances of the model.""" 1puqvcladerwxyzmnfghJsAtBiobjk
203 __pydantic_fields__: ClassVar[Dict[str, FieldInfo]] # noqa: UP006 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
204 """A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects. 1puqvcladerwxyzmnfghJsAtBiobjk
205 This replaces `Model.__fields__` from Pydantic V1.
206 """
208 __pydantic_setattr_handlers__: ClassVar[Dict[str, Callable[[BaseModel, str, Any], None]]] # noqa: UP006 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
209 """`__setattr__` handlers. Memoizing the handlers leads to a dramatic performance improvement in `__setattr__`""" 1puqvcladerwxyzmnfghJsAtBiobjk
211 __pydantic_computed_fields__: ClassVar[Dict[str, ComputedFieldInfo]] # noqa: UP006 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
212 """A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.""" 1puqvcladerwxyzmnfghJsAtBiobjk
214 __pydantic_extra__: Dict[str, Any] | None = _model_construction.NoInitField(init=False) # noqa: UP006 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
215 """A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra] is set to `'allow'`.""" 1puqvcladerwxyzmnfghJsAtBiobjk
217 __pydantic_fields_set__: set[str] = _model_construction.NoInitField(init=False) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
218 """The names of fields explicitly set during instantiation.""" 1puqvcladerwxyzmnfghJsAtBiobjk
220 __pydantic_private__: Dict[str, Any] | None = _model_construction.NoInitField(init=False) # noqa: UP006 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
221 """Values of private attributes set on the model instance.""" 1puqvcladerwxyzmnfghJsAtBiobjk
223 if not TYPE_CHECKING: 223 ↛ 241line 223 didn't jump to line 241 because the condition on line 223 was always true1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
224 # Prevent `BaseModel` from being instantiated directly
225 # (defined in an `if not TYPE_CHECKING` block for clarity and to avoid type checking errors):
226 __pydantic_core_schema__ = _mock_val_ser.MockCoreSchema( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
227 'Pydantic models should inherit from BaseModel, BaseModel cannot be instantiated directly',
228 code='base-model-instantiated',
229 )
230 __pydantic_validator__ = _mock_val_ser.MockValSer( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
231 'Pydantic models should inherit from BaseModel, BaseModel cannot be instantiated directly',
232 val_or_ser='validator',
233 code='base-model-instantiated',
234 )
235 __pydantic_serializer__ = _mock_val_ser.MockValSer( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
236 'Pydantic models should inherit from BaseModel, BaseModel cannot be instantiated directly',
237 val_or_ser='serializer',
238 code='base-model-instantiated',
239 )
241 __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
243 def __init__(self, /, **data: Any) -> None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
244 """Create a new model by parsing and validating input data from keyword arguments.
246 Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
247 validated to form a valid model.
249 `self` is explicitly positional-only to allow `self` as a field name.
250 """
251 # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks
252 __tracebackhide__ = True 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
253 validated_self = self.__pydantic_validator__.validate_python(data, self_instance=self) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
254 if self is not validated_self: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
255 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
256 'A custom validator is returning a value other than `self`.\n'
257 "Returning anything other than `self` from a top level model validator isn't supported when validating via `__init__`.\n"
258 'See the `model_validator` docs (https://docs.pydantic.dev/latest/concepts/validators/#model-validators) for more details.',
259 stacklevel=2,
260 )
262 # The following line sets a flag that we use to determine when `__init__` gets overridden by the user
263 __init__.__pydantic_base_init__ = True # pyright: ignore[reportFunctionMemberAccess] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
265 @_utils.deprecated_instance_property 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
266 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
267 def model_fields(cls) -> dict[str, FieldInfo]: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
268 """A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.
270 !!! warning
271 Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
272 Instead, you should access this attribute from the model class.
273 """
274 return getattr(cls, '__pydantic_fields__', {}) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
276 @_utils.deprecated_instance_property 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
277 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
278 def model_computed_fields(cls) -> dict[str, ComputedFieldInfo]: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
279 """A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.
281 !!! warning
282 Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
283 Instead, you should access this attribute from the model class.
284 """
285 return getattr(cls, '__pydantic_computed_fields__', {}) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
287 @property 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
288 def model_extra(self) -> dict[str, Any] | None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
289 """Get extra fields set during validation.
291 Returns:
292 A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
293 """
294 return self.__pydantic_extra__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
296 @property 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
297 def model_fields_set(self) -> set[str]: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
298 """Returns the set of fields that have been explicitly set on this model instance.
300 Returns:
301 A set of strings representing the fields that have been set,
302 i.e. that were not filled from defaults.
303 """
304 return self.__pydantic_fields_set__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
306 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
307 def model_construct(cls, _fields_set: set[str] | None = None, **values: Any) -> Self: # noqa: C901 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
308 """Creates a new instance of the `Model` class with validated data.
310 Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
311 Default values are respected, but no other validation is performed.
313 !!! note
314 `model_construct()` generally respects the `model_config.extra` setting on the provided model.
315 That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
316 and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
317 Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
318 an error if extra values are passed, but they will be ignored.
320 Args:
321 _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
322 this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
323 Otherwise, the field names from the `values` argument will be used.
324 values: Trusted or pre-validated data dictionary.
326 Returns:
327 A new instance of the `Model` class with validated data.
328 """
329 m = cls.__new__(cls) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
330 fields_values: dict[str, Any] = {} 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
331 fields_set = set() 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
333 for name, field in cls.__pydantic_fields__.items(): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
334 if field.alias is not None and field.alias in values: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
335 fields_values[name] = values.pop(field.alias) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
336 fields_set.add(name) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
338 if (name not in fields_set) and (field.validation_alias is not None): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
339 validation_aliases: list[str | AliasPath] = ( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
340 field.validation_alias.choices
341 if isinstance(field.validation_alias, AliasChoices)
342 else [field.validation_alias]
343 )
345 for alias in validation_aliases: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
346 if isinstance(alias, str) and alias in values: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
347 fields_values[name] = values.pop(alias) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
348 fields_set.add(name) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
349 break 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
350 elif isinstance(alias, AliasPath): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
351 value = alias.search_dict_for_path(values) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
352 if value is not PydanticUndefined: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
353 fields_values[name] = value 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
354 fields_set.add(name) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
355 break 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
357 if name not in fields_set: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
358 if name in values: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
359 fields_values[name] = values.pop(name) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
360 fields_set.add(name) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
361 elif not field.is_required(): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
362 fields_values[name] = field.get_default(call_default_factory=True, validated_data=fields_values) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
363 if _fields_set is None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
364 _fields_set = fields_set 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
366 _extra: dict[str, Any] | None = values if cls.model_config.get('extra') == 'allow' else None 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
367 _object_setattr(m, '__dict__', fields_values) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
368 _object_setattr(m, '__pydantic_fields_set__', _fields_set) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
369 if not cls.__pydantic_root_model__: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
370 _object_setattr(m, '__pydantic_extra__', _extra) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
372 if cls.__pydantic_post_init__: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
373 m.model_post_init(None) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
374 # update private attributes with values set
375 if hasattr(m, '__pydantic_private__') and m.__pydantic_private__ is not None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
376 for k, v in values.items(): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
377 if k in m.__private_attributes__: 377 ↛ 376line 377 didn't jump to line 376 because the condition on line 377 was always true1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
378 m.__pydantic_private__[k] = v 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
380 elif not cls.__pydantic_root_model__: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
381 # Note: if there are any private attributes, cls.__pydantic_post_init__ would exist
382 # Since it doesn't, that means that `__pydantic_private__` should be set to None
383 _object_setattr(m, '__pydantic_private__', None) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
385 return m 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
387 def model_copy(self, *, update: Mapping[str, Any] | None = None, deep: bool = False) -> Self: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
388 """!!! abstract "Usage Documentation"
389 [`model_copy`](../concepts/serialization.md#model_copy)
391 Returns a copy of the model.
393 !!! note
394 The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
395 might have unexpected side effects if you store anything in it, on top of the model
396 fields (e.g. the value of [cached properties][functools.cached_property]).
398 Args:
399 update: Values to change/add in the new model. Note: the data is not validated
400 before creating the new model. You should trust this data.
401 deep: Set to `True` to make a deep copy of the model.
403 Returns:
404 New model instance.
405 """
406 copied = self.__deepcopy__() if deep else self.__copy__() 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
407 if update: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
408 if self.model_config.get('extra') == 'allow': 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
409 for k, v in update.items(): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
410 if k in self.__pydantic_fields__: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
411 copied.__dict__[k] = v 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
412 else:
413 if copied.__pydantic_extra__ is None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
414 copied.__pydantic_extra__ = {} 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
415 copied.__pydantic_extra__[k] = v 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
416 else:
417 copied.__dict__.update(update) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
418 copied.__pydantic_fields_set__.update(update.keys()) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
419 return copied 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
421 def model_dump( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
422 self,
423 *,
424 mode: Literal['json', 'python'] | str = 'python',
425 include: IncEx | None = None,
426 exclude: IncEx | None = None,
427 context: Any | None = None,
428 by_alias: bool | None = None,
429 exclude_unset: bool = False,
430 exclude_defaults: bool = False,
431 exclude_none: bool = False,
432 round_trip: bool = False,
433 warnings: bool | Literal['none', 'warn', 'error'] = True,
434 fallback: Callable[[Any], Any] | None = None,
435 serialize_as_any: bool = False,
436 ) -> dict[str, Any]:
437 """!!! abstract "Usage Documentation"
438 [`model_dump`](../concepts/serialization.md#modelmodel_dump)
440 Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
442 Args:
443 mode: The mode in which `to_python` should run.
444 If mode is 'json', the output will only contain JSON serializable types.
445 If mode is 'python', the output may contain non-JSON-serializable Python objects.
446 include: A set of fields to include in the output.
447 exclude: A set of fields to exclude from the output.
448 context: Additional context to pass to the serializer.
449 by_alias: Whether to use the field's alias in the dictionary key if defined.
450 exclude_unset: Whether to exclude fields that have not been explicitly set.
451 exclude_defaults: Whether to exclude fields that are set to their default value.
452 exclude_none: Whether to exclude fields that have a value of `None`.
453 round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
454 warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
455 "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
456 fallback: A function to call when an unknown value is encountered. If not provided,
457 a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
458 serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
460 Returns:
461 A dictionary representation of the model.
462 """
463 return self.__pydantic_serializer__.to_python( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
464 self,
465 mode=mode,
466 by_alias=by_alias,
467 include=include,
468 exclude=exclude,
469 context=context,
470 exclude_unset=exclude_unset,
471 exclude_defaults=exclude_defaults,
472 exclude_none=exclude_none,
473 round_trip=round_trip,
474 warnings=warnings,
475 fallback=fallback,
476 serialize_as_any=serialize_as_any,
477 )
479 def model_dump_json( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
480 self,
481 *,
482 indent: int | None = None,
483 ensure_ascii: bool = False,
484 include: IncEx | None = None,
485 exclude: IncEx | None = None,
486 context: Any | None = None,
487 by_alias: bool | None = None,
488 exclude_unset: bool = False,
489 exclude_defaults: bool = False,
490 exclude_none: bool = False,
491 round_trip: bool = False,
492 warnings: bool | Literal['none', 'warn', 'error'] = True,
493 fallback: Callable[[Any], Any] | None = None,
494 serialize_as_any: bool = False,
495 ) -> str:
496 """!!! abstract "Usage Documentation"
497 [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
499 Generates a JSON representation of the model using Pydantic's `to_json` method.
501 Args:
502 indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
503 ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
504 If `False` (the default), these characters will be output as-is.
505 include: Field(s) to include in the JSON output.
506 exclude: Field(s) to exclude from the JSON output.
507 context: Additional context to pass to the serializer.
508 by_alias: Whether to serialize using field aliases.
509 exclude_unset: Whether to exclude fields that have not been explicitly set.
510 exclude_defaults: Whether to exclude fields that are set to their default value.
511 exclude_none: Whether to exclude fields that have a value of `None`.
512 round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
513 warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
514 "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
515 fallback: A function to call when an unknown value is encountered. If not provided,
516 a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
517 serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
519 Returns:
520 A JSON string representation of the model.
521 """
522 return self.__pydantic_serializer__.to_json( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
523 self,
524 indent=indent,
525 ensure_ascii=ensure_ascii,
526 include=include,
527 exclude=exclude,
528 context=context,
529 by_alias=by_alias,
530 exclude_unset=exclude_unset,
531 exclude_defaults=exclude_defaults,
532 exclude_none=exclude_none,
533 round_trip=round_trip,
534 warnings=warnings,
535 fallback=fallback,
536 serialize_as_any=serialize_as_any,
537 ).decode()
539 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
540 def model_json_schema( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
541 cls,
542 by_alias: bool = True,
543 ref_template: str = DEFAULT_REF_TEMPLATE,
544 schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema,
545 mode: JsonSchemaMode = 'validation',
546 ) -> dict[str, Any]:
547 """Generates a JSON schema for a model class.
549 Args:
550 by_alias: Whether to use attribute aliases or not.
551 ref_template: The reference template.
552 schema_generator: To override the logic used to generate the JSON schema, as a subclass of
553 `GenerateJsonSchema` with your desired modifications
554 mode: The mode in which to generate the schema.
556 Returns:
557 The JSON schema for the given model class.
558 """
559 return model_json_schema( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
560 cls, by_alias=by_alias, ref_template=ref_template, schema_generator=schema_generator, mode=mode
561 )
563 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
564 def model_parametrized_name(cls, params: tuple[type[Any], ...]) -> str: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
565 """Compute the class name for parametrizations of generic classes.
567 This method can be overridden to achieve a custom naming scheme for generic BaseModels.
569 Args:
570 params: Tuple of types of the class. Given a generic class
571 `Model` with 2 type variables and a concrete model `Model[str, int]`,
572 the value `(str, int)` would be passed to `params`.
574 Returns:
575 String representing the new class where `params` are passed to `cls` as type variables.
577 Raises:
578 TypeError: Raised when trying to generate concrete names for non-generic models.
579 """
580 if not issubclass(cls, typing.Generic): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
581 raise TypeError('Concrete names should only be generated for generic models.') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
583 # Any strings received should represent forward references, so we handle them specially below.
584 # If we eventually move toward wrapping them in a ForwardRef in __class_getitem__ in the future,
585 # we may be able to remove this special case.
586 param_names = [param if isinstance(param, str) else _repr.display_as_type(param) for param in params] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
587 params_component = ', '.join(param_names) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
588 return f'{cls.__name__}[{params_component}]' 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
590 def model_post_init(self, context: Any, /) -> None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
591 """Override this method to perform additional initialization after `__init__` and `model_construct`.
592 This is useful if you want to do some validation that requires the entire model to be initialized.
593 """
594 pass 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
596 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
597 def model_rebuild( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
598 cls,
599 *,
600 force: bool = False,
601 raise_errors: bool = True,
602 _parent_namespace_depth: int = 2,
603 _types_namespace: MappingNamespace | None = None,
604 ) -> bool | None:
605 """Try to rebuild the pydantic-core schema for the model.
607 This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
608 the initial attempt to build the schema, and automatic rebuilding fails.
610 Args:
611 force: Whether to force the rebuilding of the model schema, defaults to `False`.
612 raise_errors: Whether to raise errors, defaults to `True`.
613 _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
614 _types_namespace: The types namespace, defaults to `None`.
616 Returns:
617 Returns `None` if the schema is already "complete" and rebuilding was not required.
618 If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
619 """
620 already_complete = cls.__pydantic_complete__ 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
621 if already_complete and not force: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
622 return None 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
624 cls.__pydantic_complete__ = False 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
626 for attr in ('__pydantic_core_schema__', '__pydantic_validator__', '__pydantic_serializer__'): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
627 if attr in cls.__dict__ and not isinstance(getattr(cls, attr), _mock_val_ser.MockValSer): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
628 # Deleting the validator/serializer is necessary as otherwise they can get reused in
629 # pydantic-core. We do so only if they aren't mock instances, otherwise — as `model_rebuild()`
630 # isn't thread-safe — concurrent model instantiations can lead to the parent validator being used.
631 # Same applies for the core schema that can be reused in schema generation.
632 delattr(cls, attr) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
634 if _types_namespace is not None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
635 rebuild_ns = _types_namespace 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
636 elif _parent_namespace_depth > 0: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
637 rebuild_ns = _typing_extra.parent_frame_namespace(parent_depth=_parent_namespace_depth, force=True) or {} 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
638 else:
639 rebuild_ns = {} 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
641 parent_ns = _model_construction.unpack_lenient_weakvaluedict(cls.__pydantic_parent_namespace__) or {} 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
643 ns_resolver = _namespace_utils.NsResolver( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
644 parent_namespace={**rebuild_ns, **parent_ns},
645 )
647 return _model_construction.complete_model_class( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
648 cls,
649 _config.ConfigWrapper(cls.model_config, check=False),
650 ns_resolver,
651 raise_errors=raise_errors,
652 # If the model was already complete, we don't need to call the hook again.
653 call_on_complete_hook=not already_complete,
654 )
656 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
657 def model_validate( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
658 cls,
659 obj: Any,
660 *,
661 strict: bool | None = None,
662 from_attributes: bool | None = None,
663 context: Any | None = None,
664 by_alias: bool | None = None,
665 by_name: bool | None = None,
666 ) -> Self:
667 """Validate a pydantic model instance.
669 Args:
670 obj: The object to validate.
671 strict: Whether to enforce types strictly.
672 from_attributes: Whether to extract data from object attributes.
673 context: Additional context to pass to the validator.
674 by_alias: Whether to use the field's alias when validating against the provided input data.
675 by_name: Whether to use the field's name when validating against the provided input data.
677 Raises:
678 ValidationError: If the object could not be validated.
680 Returns:
681 The validated model instance.
682 """
683 # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks
684 __tracebackhide__ = True 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
686 if by_alias is False and by_name is not True: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
687 raise PydanticUserError( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
688 'At least one of `by_alias` or `by_name` must be set to True.',
689 code='validate-by-alias-and-name-false',
690 )
692 return cls.__pydantic_validator__.validate_python( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
693 obj, strict=strict, from_attributes=from_attributes, context=context, by_alias=by_alias, by_name=by_name
694 )
696 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
697 def model_validate_json( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
698 cls,
699 json_data: str | bytes | bytearray,
700 *,
701 strict: bool | None = None,
702 context: Any | None = None,
703 by_alias: bool | None = None,
704 by_name: bool | None = None,
705 ) -> Self:
706 """!!! abstract "Usage Documentation"
707 [JSON Parsing](../concepts/json.md#json-parsing)
709 Validate the given JSON data against the Pydantic model.
711 Args:
712 json_data: The JSON data to validate.
713 strict: Whether to enforce types strictly.
714 context: Extra variables to pass to the validator.
715 by_alias: Whether to use the field's alias when validating against the provided input data.
716 by_name: Whether to use the field's name when validating against the provided input data.
718 Returns:
719 The validated Pydantic model.
721 Raises:
722 ValidationError: If `json_data` is not a JSON string or the object could not be validated.
723 """
724 # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks
725 __tracebackhide__ = True 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
727 if by_alias is False and by_name is not True: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
728 raise PydanticUserError( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
729 'At least one of `by_alias` or `by_name` must be set to True.',
730 code='validate-by-alias-and-name-false',
731 )
733 return cls.__pydantic_validator__.validate_json( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
734 json_data, strict=strict, context=context, by_alias=by_alias, by_name=by_name
735 )
737 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
738 def model_validate_strings( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
739 cls,
740 obj: Any,
741 *,
742 strict: bool | None = None,
743 context: Any | None = None,
744 by_alias: bool | None = None,
745 by_name: bool | None = None,
746 ) -> Self:
747 """Validate the given object with string data against the Pydantic model.
749 Args:
750 obj: The object containing string data to validate.
751 strict: Whether to enforce types strictly.
752 context: Extra variables to pass to the validator.
753 by_alias: Whether to use the field's alias when validating against the provided input data.
754 by_name: Whether to use the field's name when validating against the provided input data.
756 Returns:
757 The validated Pydantic model.
758 """
759 # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks
760 __tracebackhide__ = True 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
762 if by_alias is False and by_name is not True: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
763 raise PydanticUserError( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
764 'At least one of `by_alias` or `by_name` must be set to True.',
765 code='validate-by-alias-and-name-false',
766 )
768 return cls.__pydantic_validator__.validate_strings( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
769 obj, strict=strict, context=context, by_alias=by_alias, by_name=by_name
770 )
772 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
773 def __get_pydantic_core_schema__(cls, source: type[BaseModel], handler: GetCoreSchemaHandler, /) -> CoreSchema: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
774 # This warning is only emitted when calling `super().__get_pydantic_core_schema__` from a model subclass.
775 # In the generate schema logic, this method (`BaseModel.__get_pydantic_core_schema__`) is special cased to
776 # *not* be called if not overridden.
777 warnings.warn(
778 'The `__get_pydantic_core_schema__` method of the `BaseModel` class is deprecated. If you are calling '
779 '`super().__get_pydantic_core_schema__` when overriding the method on a Pydantic model, consider using '
780 '`handler(source)` instead. However, note that overriding this method on models can lead to unexpected '
781 'side effects.',
782 PydanticDeprecatedSince211,
783 stacklevel=2,
784 )
785 # Logic copied over from `GenerateSchema._model_schema`:
786 schema = cls.__dict__.get('__pydantic_core_schema__')
787 if schema is not None and not isinstance(schema, _mock_val_ser.MockCoreSchema):
788 return cls.__pydantic_core_schema__
790 return handler(source)
792 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
793 def __get_pydantic_json_schema__( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
794 cls,
795 core_schema: CoreSchema,
796 handler: GetJsonSchemaHandler,
797 /,
798 ) -> JsonSchemaValue:
799 """Hook into generating the model's JSON schema.
801 Args:
802 core_schema: A `pydantic-core` CoreSchema.
803 You can ignore this argument and call the handler with a new CoreSchema,
804 wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
805 or just call the handler with the original schema.
806 handler: Call into Pydantic's internal JSON schema generation.
807 This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
808 generation fails.
809 Since this gets called by `BaseModel.model_json_schema` you can override the
810 `schema_generator` argument to that function to change JSON schema generation globally
811 for a type.
813 Returns:
814 A JSON schema, as a Python object.
815 """
816 return handler(core_schema) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
818 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
819 def __pydantic_init_subclass__(cls, **kwargs: Any) -> None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
820 """This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
821 only after basic class initialization is complete. In particular, attributes like `model_fields` will
822 be present when this is called, but forward annotations are not guaranteed to be resolved yet,
823 meaning that creating an instance of the class may fail.
825 This is necessary because `__init_subclass__` will always be called by `type.__new__`,
826 and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
827 `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
829 This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
830 any kwargs passed to the class definition that aren't used internally by Pydantic.
832 Args:
833 **kwargs: Any keyword arguments passed to the class definition that aren't used internally
834 by Pydantic.
836 Note:
837 You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
838 instead, which is called once the class and its fields are fully initialized and ready for validation.
839 """
840 pass 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
842 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
843 def __pydantic_on_complete__(cls) -> None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
844 """This is called once the class and its fields are fully initialized and ready to be used.
846 This typically happens when the class is created (just before
847 [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
848 except when forward annotations are used that could not immediately be resolved.
849 In that case, it will be called later, when the model is rebuilt automatically or explicitly using
850 [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
851 """
852 pass 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
854 def __class_getitem__( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
855 cls, typevar_values: type[Any] | tuple[type[Any], ...]
856 ) -> type[BaseModel] | _forward_ref.PydanticRecursiveRef:
857 cached = _generics.get_cached_generic_type_early(cls, typevar_values) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
858 if cached is not None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
859 return cached 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
861 if cls is BaseModel: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
862 raise TypeError('Type parameters should be placed on typing.Generic, not BaseModel') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
863 if not hasattr(cls, '__parameters__'): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
864 raise TypeError(f'{cls} cannot be parametrized because it does not inherit from typing.Generic') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
865 if not cls.__pydantic_generic_metadata__['parameters'] and typing.Generic not in cls.__bases__: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
866 raise TypeError(f'{cls} is not a generic class') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
868 if not isinstance(typevar_values, tuple): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
869 typevar_values = (typevar_values,) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
871 # For a model `class Model[T, U, V = int](BaseModel): ...` parametrized with `(str, bool)`,
872 # this gives us `{T: str, U: bool, V: int}`:
873 typevars_map = _generics.map_generic_model_arguments(cls, typevar_values) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
874 # We also update the provided args to use defaults values (`(str, bool)` becomes `(str, bool, int)`):
875 typevar_values = tuple(v for v in typevars_map.values()) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
877 if _utils.all_identical(typevars_map.keys(), typevars_map.values()) and typevars_map: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
878 submodel = cls # if arguments are equal to parameters it's the same object 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
879 _generics.set_cached_generic_type(cls, typevar_values, submodel) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
880 else:
881 parent_args = cls.__pydantic_generic_metadata__['args'] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
882 if not parent_args: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
883 args = typevar_values 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
884 else:
885 args = tuple(_generics.replace_types(arg, typevars_map) for arg in parent_args) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
887 origin = cls.__pydantic_generic_metadata__['origin'] or cls 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
888 model_name = origin.model_parametrized_name(args) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
889 params = tuple( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
890 {param: None for param in _generics.iter_contained_typevars(typevars_map.values())}
891 ) # use dict as ordered set
893 with _generics.generic_recursion_self_type(origin, args) as maybe_self_type: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
894 cached = _generics.get_cached_generic_type_late(cls, typevar_values, origin, args) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
895 if cached is not None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
896 return cached 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
898 if maybe_self_type is not None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
899 return maybe_self_type 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
901 # Attempt to rebuild the origin in case new types have been defined
902 try: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
903 # depth 2 gets you above this __class_getitem__ call.
904 # Note that we explicitly provide the parent ns, otherwise
905 # `model_rebuild` will use the parent ns no matter if it is the ns of a module.
906 # We don't want this here, as this has unexpected effects when a model
907 # is being parametrized during a forward annotation evaluation.
908 parent_ns = _typing_extra.parent_frame_namespace(parent_depth=2) or {} 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
909 origin.model_rebuild(_types_namespace=parent_ns) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
910 except PydanticUndefinedAnnotation: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
911 # It's okay if it fails, it just means there are still undefined types
912 # that could be evaluated later.
913 pass 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
915 submodel = _generics.create_generic_submodel(model_name, origin, args, params) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
917 _generics.set_cached_generic_type(cls, typevar_values, submodel, origin, args) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
919 return submodel 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
921 def __copy__(self) -> Self: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
922 """Returns a shallow copy of the model."""
923 cls = type(self) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
924 m = cls.__new__(cls) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
925 _object_setattr(m, '__dict__', copy(self.__dict__)) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
926 _object_setattr(m, '__pydantic_extra__', copy(self.__pydantic_extra__)) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
927 _object_setattr(m, '__pydantic_fields_set__', copy(self.__pydantic_fields_set__)) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
929 if not hasattr(self, '__pydantic_private__') or self.__pydantic_private__ is None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
930 _object_setattr(m, '__pydantic_private__', None) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
931 else:
932 _object_setattr( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
933 m,
934 '__pydantic_private__',
935 {k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined},
936 )
938 return m 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
940 def __deepcopy__(self, memo: dict[int, Any] | None = None) -> Self: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
941 """Returns a deep copy of the model."""
942 cls = type(self) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
943 m = cls.__new__(cls) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
944 _object_setattr(m, '__dict__', deepcopy(self.__dict__, memo=memo)) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
945 _object_setattr(m, '__pydantic_extra__', deepcopy(self.__pydantic_extra__, memo=memo)) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
946 # This next line doesn't need a deepcopy because __pydantic_fields_set__ is a set[str],
947 # and attempting a deepcopy would be marginally slower.
948 _object_setattr(m, '__pydantic_fields_set__', copy(self.__pydantic_fields_set__)) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
950 if not hasattr(self, '__pydantic_private__') or self.__pydantic_private__ is None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
951 _object_setattr(m, '__pydantic_private__', None) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
952 else:
953 _object_setattr( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
954 m,
955 '__pydantic_private__',
956 deepcopy({k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined}, memo=memo),
957 )
959 return m 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
961 if not TYPE_CHECKING: 961 ↛ 1097line 961 didn't jump to line 1097 because the condition on line 961 was always true1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
962 # We put `__getattr__` in a non-TYPE_CHECKING block because otherwise, mypy allows arbitrary attribute access
963 # The same goes for __setattr__ and __delattr__, see: https://github.com/pydantic/pydantic/issues/8643
965 def __getattr__(self, item: str) -> Any: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
966 private_attributes = object.__getattribute__(self, '__private_attributes__') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
967 if item in private_attributes: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
968 attribute = private_attributes[item] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
969 if hasattr(attribute, '__get__'): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
970 return attribute.__get__(self, type(self)) # type: ignore 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
972 try: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
973 # Note: self.__pydantic_private__ cannot be None if self.__private_attributes__ has items
974 return self.__pydantic_private__[item] # type: ignore 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
975 except KeyError as exc: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
976 raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}') from exc 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
977 else:
978 # `__pydantic_extra__` can fail to be set if the model is not yet fully initialized.
979 # See `BaseModel.__repr_args__` for more details
980 try: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
981 pydantic_extra = object.__getattribute__(self, '__pydantic_extra__') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
982 except AttributeError: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
983 pydantic_extra = None 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
985 if pydantic_extra: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
986 try: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
987 return pydantic_extra[item] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
988 except KeyError as exc: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
989 raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}') from exc 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
990 else:
991 if hasattr(self.__class__, item): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
992 return super().__getattribute__(item) # Raises AttributeError if appropriate 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
993 else:
994 # this is the current error
995 raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
997 def __setattr__(self, name: str, value: Any) -> None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
998 if (setattr_handler := self.__pydantic_setattr_handlers__.get(name)) is not None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
999 setattr_handler(self, name, value) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1000 # if None is returned from _setattr_handler, the attribute was set directly
1001 elif (setattr_handler := self._setattr_handler(name, value)) is not None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1002 setattr_handler(self, name, value) # call here to not memo on possibly unknown fields 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1003 self.__pydantic_setattr_handlers__[name] = setattr_handler # memoize the handler for faster access 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1005 def _setattr_handler(self, name: str, value: Any) -> Callable[[BaseModel, str, Any], None] | None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1006 """Get a handler for setting an attribute on the model instance.
1008 Returns:
1009 A handler for setting an attribute on the model instance. Used for memoization of the handler.
1010 Memoizing the handlers leads to a dramatic performance improvement in `__setattr__`
1011 Returns `None` when memoization is not safe, then the attribute is set directly.
1012 """
1013 cls = self.__class__ 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1014 if name in cls.__class_vars__: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1015 raise AttributeError( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1016 f'{name!r} is a ClassVar of `{cls.__name__}` and cannot be set on an instance. '
1017 f'If you want to set a value on the class, use `{cls.__name__}.{name} = value`.'
1018 )
1019 elif not _fields.is_valid_field_name(name): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1020 if (attribute := cls.__private_attributes__.get(name)) is not None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1021 if hasattr(attribute, '__set__'): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1022 return lambda model, _name, val: attribute.__set__(model, val) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1023 else:
1024 return _SIMPLE_SETATTR_HANDLERS['private'] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1025 else:
1026 _object_setattr(self, name, value) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1027 return None # Can not return memoized handler with possibly freeform attr names 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1029 attr = getattr(cls, name, None) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1030 # NOTE: We currently special case properties and `cached_property`, but we might need
1031 # to generalize this to all data/non-data descriptors at some point. For non-data descriptors
1032 # (such as `cached_property`), it isn't obvious though. `cached_property` caches the value
1033 # to the instance's `__dict__`, but other non-data descriptors might do things differently.
1034 if isinstance(attr, cached_property): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1035 return _SIMPLE_SETATTR_HANDLERS['cached_property'] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1037 _check_frozen(cls, name, value) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1039 # We allow properties to be set only on non frozen models for now (to match dataclasses).
1040 # This can be changed if it ever gets requested.
1041 if isinstance(attr, property): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1042 return lambda model, _name, val: attr.__set__(model, val) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1043 elif cls.model_config.get('validate_assignment'): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1044 return _SIMPLE_SETATTR_HANDLERS['validate_assignment'] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1045 elif name not in cls.__pydantic_fields__: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1046 if cls.model_config.get('extra') != 'allow': 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1047 # TODO - matching error
1048 raise ValueError(f'"{cls.__name__}" object has no field "{name}"') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1049 elif attr is None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1050 # attribute does not exist, so put it in extra
1051 self.__pydantic_extra__[name] = value 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1052 return None # Can not return memoized handler with possibly freeform attr names 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1053 else:
1054 # attribute _does_ exist, and was not in extra, so update it
1055 return _SIMPLE_SETATTR_HANDLERS['extra_known'] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1056 else:
1057 return _SIMPLE_SETATTR_HANDLERS['model_field'] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1059 def __delattr__(self, item: str) -> Any: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1060 cls = self.__class__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1062 if item in self.__private_attributes__: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1063 attribute = self.__private_attributes__[item] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1064 if hasattr(attribute, '__delete__'): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1065 attribute.__delete__(self) # type: ignore 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1066 return 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1068 try: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1069 # Note: self.__pydantic_private__ cannot be None if self.__private_attributes__ has items
1070 del self.__pydantic_private__[item] # type: ignore 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1071 return 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1072 except KeyError as exc: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1073 raise AttributeError(f'{cls.__name__!r} object has no attribute {item!r}') from exc 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1075 # Allow cached properties to be deleted (even if the class is frozen):
1076 attr = getattr(cls, item, None) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1077 if isinstance(attr, cached_property): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1078 return object.__delattr__(self, item) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1080 _check_frozen(cls, name=item, value=None) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1082 if item in self.__pydantic_fields__: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1083 object.__delattr__(self, item) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1084 elif self.__pydantic_extra__ is not None and item in self.__pydantic_extra__: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1085 del self.__pydantic_extra__[item] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1086 else:
1087 try: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1088 object.__delattr__(self, item) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1089 except AttributeError: 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1090 raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}') 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1092 # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
1093 # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
1094 def __replace__(self, **changes: Any) -> Self: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1095 return self.model_copy(update=changes) 1adefghbjk
1097 def __getstate__(self) -> dict[Any, Any]: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1098 private = self.__pydantic_private__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1099 if private: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1100 private = {k: v for k, v in private.items() if v is not PydanticUndefined} 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1101 return { 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1102 '__dict__': self.__dict__,
1103 '__pydantic_extra__': self.__pydantic_extra__,
1104 '__pydantic_fields_set__': self.__pydantic_fields_set__,
1105 '__pydantic_private__': private,
1106 }
1108 def __setstate__(self, state: dict[Any, Any]) -> None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1109 _object_setattr(self, '__pydantic_fields_set__', state.get('__pydantic_fields_set__', {})) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1110 _object_setattr(self, '__pydantic_extra__', state.get('__pydantic_extra__', {})) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1111 _object_setattr(self, '__pydantic_private__', state.get('__pydantic_private__', {})) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1112 _object_setattr(self, '__dict__', state.get('__dict__', {})) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1114 if not TYPE_CHECKING: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1116 def __eq__(self, other: Any) -> bool: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1117 if isinstance(other, BaseModel): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1118 # When comparing instances of generic types for equality, as long as all field values are equal,
1119 # only require their generic origin types to be equal, rather than exact type equality.
1120 # This prevents headaches like MyGeneric(x=1) != MyGeneric[Any](x=1).
1121 self_type = self.__pydantic_generic_metadata__['origin'] or self.__class__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1122 other_type = other.__pydantic_generic_metadata__['origin'] or other.__class__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1124 # Perform common checks first
1125 if not ( 1CDFr
1126 self_type == other_type
1127 and getattr(self, '__pydantic_private__', None) == getattr(other, '__pydantic_private__', None)
1128 and self.__pydantic_extra__ == other.__pydantic_extra__
1129 ):
1130 return False 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1132 # We only want to compare pydantic fields but ignoring fields is costly.
1133 # We'll perform a fast check first, and fallback only when needed
1134 # See GH-7444 and GH-7825 for rationale and a performance benchmark
1136 # First, do the fast (and sometimes faulty) __dict__ comparison
1137 if self.__dict__ == other.__dict__: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1138 # If the check above passes, then pydantic fields are equal, we can return early
1139 return True 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1141 # We don't want to trigger unnecessary costly filtering of __dict__ on all unequal objects, so we return
1142 # early if there are no keys to ignore (we would just return False later on anyway)
1143 model_fields = type(self).__pydantic_fields__.keys() 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1144 if self.__dict__.keys() <= model_fields and other.__dict__.keys() <= model_fields: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1145 return False 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1147 # If we reach here, there are non-pydantic-fields keys, mapped to unequal values, that we need to ignore
1148 # Resort to costly filtering of the __dict__ objects
1149 # We use operator.itemgetter because it is much faster than dict comprehensions
1150 # NOTE: Contrary to standard python class and instances, when the Model class has a default value for an
1151 # attribute and the model instance doesn't have a corresponding attribute, accessing the missing attribute
1152 # raises an error in BaseModel.__getattr__ instead of returning the class attribute
1153 # So we can use operator.itemgetter() instead of operator.attrgetter()
1154 getter = operator.itemgetter(*model_fields) if model_fields else lambda _: _utils._SENTINEL 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1155 try: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1156 return getter(self.__dict__) == getter(other.__dict__) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1157 except KeyError:
1158 # In rare cases (such as when using the deprecated BaseModel.copy() method),
1159 # the __dict__ may not contain all model fields, which is how we can get here.
1160 # getter(self.__dict__) is much faster than any 'safe' method that accounts
1161 # for missing keys, and wrapping it in a `try` doesn't slow things down much
1162 # in the common case.
1163 self_fields_proxy = _utils.SafeGetItemProxy(self.__dict__)
1164 other_fields_proxy = _utils.SafeGetItemProxy(other.__dict__)
1165 return getter(self_fields_proxy) == getter(other_fields_proxy)
1167 # other instance is not a BaseModel
1168 else:
1169 return NotImplemented # delegate to the other item in the comparison 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1171 if TYPE_CHECKING: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1172 # We put `__init_subclass__` in a TYPE_CHECKING block because, even though we want the type-checking benefits
1173 # described in the signature of `__init_subclass__` below, we don't want to modify the default behavior of
1174 # subclass initialization.
1176 def __init_subclass__(cls, **kwargs: Unpack[ConfigDict]):
1177 """This signature is included purely to help type-checkers check arguments to class declaration, which
1178 provides a way to conveniently set model_config key/value pairs.
1180 ```python
1181 from pydantic import BaseModel
1183 class MyModel(BaseModel, extra='allow'): ...
1184 ```
1186 However, this may be deceiving, since the _actual_ calls to `__init_subclass__` will not receive any
1187 of the config arguments, and will only receive any keyword arguments passed during class initialization
1188 that are _not_ expected keys in ConfigDict. (This is due to the way `ModelMetaclass.__new__` works.)
1190 Args:
1191 **kwargs: Keyword arguments passed to the class definition, which set model_config
1193 Note:
1194 You may want to override `__pydantic_init_subclass__` instead, which behaves similarly but is called
1195 *after* the class is fully initialized.
1196 """
1198 def __iter__(self) -> TupleGenerator: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1199 """So `dict(model)` works."""
1200 yield from [(k, v) for (k, v) in self.__dict__.items() if not k.startswith('_')] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1201 extra = self.__pydantic_extra__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1202 if extra: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1203 yield from extra.items() 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1205 def __repr__(self) -> str: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1206 return f'{self.__repr_name__()}({self.__repr_str__(", ")})' 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1208 def __repr_args__(self) -> _repr.ReprArgs: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1209 # Eagerly create the repr of computed fields, as this may trigger access of cached properties and as such
1210 # modify the instance's `__dict__`. If we don't do it now, it could happen when iterating over the `__dict__`
1211 # below if the instance happens to be referenced in a field, and would modify the `__dict__` size *during* iteration.
1212 computed_fields_repr_args = [ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1213 (k, getattr(self, k)) for k, v in self.__pydantic_computed_fields__.items() if v.repr
1214 ]
1216 for k, v in self.__dict__.items(): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1217 field = self.__pydantic_fields__.get(k) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1218 if field and field.repr: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1219 if v is not self: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1220 yield k, v 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1221 else:
1222 yield k, self.__repr_recursion__(v) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1223 # `__pydantic_extra__` can fail to be set if the model is not yet fully initialized.
1224 # This can happen if a `ValidationError` is raised during initialization and the instance's
1225 # repr is generated as part of the exception handling. Therefore, we use `getattr` here
1226 # with a fallback, even though the type hints indicate the attribute will always be present.
1227 try: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1228 pydantic_extra = object.__getattribute__(self, '__pydantic_extra__') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1229 except AttributeError: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1230 pydantic_extra = None 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1232 if pydantic_extra is not None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1233 yield from ((k, v) for k, v in pydantic_extra.items()) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1234 yield from computed_fields_repr_args 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1236 # take logic from `_repr.Representation` without the side effects of inheritance, see #5740
1237 __repr_name__ = _repr.Representation.__repr_name__ 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1238 __repr_recursion__ = _repr.Representation.__repr_recursion__ 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1239 __repr_str__ = _repr.Representation.__repr_str__ 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1240 __pretty__ = _repr.Representation.__pretty__ 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1241 __rich_repr__ = _repr.Representation.__rich_repr__ 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1243 def __str__(self) -> str: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1244 return self.__repr_str__(' ') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1246 # ##### Deprecated methods from v1 #####
1247 @property 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1248 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1249 'The `__fields__` attribute is deprecated, use `model_fields` instead.', category=None
1250 )
1251 def __fields__(self) -> dict[str, FieldInfo]: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1252 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1253 'The `__fields__` attribute is deprecated, use `model_fields` instead.',
1254 category=PydanticDeprecatedSince20,
1255 stacklevel=2,
1256 )
1257 return getattr(type(self), '__pydantic_fields__', {}) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1259 @property 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1260 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1261 'The `__fields_set__` attribute is deprecated, use `model_fields_set` instead.',
1262 category=None,
1263 )
1264 def __fields_set__(self) -> set[str]: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1265 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1266 'The `__fields_set__` attribute is deprecated, use `model_fields_set` instead.',
1267 category=PydanticDeprecatedSince20,
1268 stacklevel=2,
1269 )
1270 return self.__pydantic_fields_set__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1272 @typing_extensions.deprecated('The `dict` method is deprecated; use `model_dump` instead.', category=None) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1273 def dict( # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1274 self,
1275 *,
1276 include: IncEx | None = None,
1277 exclude: IncEx | None = None,
1278 by_alias: bool = False,
1279 exclude_unset: bool = False,
1280 exclude_defaults: bool = False,
1281 exclude_none: bool = False,
1282 ) -> Dict[str, Any]: # noqa UP006
1283 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1284 'The `dict` method is deprecated; use `model_dump` instead.',
1285 category=PydanticDeprecatedSince20,
1286 stacklevel=2,
1287 )
1288 return self.model_dump( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1289 include=include,
1290 exclude=exclude,
1291 by_alias=by_alias,
1292 exclude_unset=exclude_unset,
1293 exclude_defaults=exclude_defaults,
1294 exclude_none=exclude_none,
1295 )
1297 @typing_extensions.deprecated('The `json` method is deprecated; use `model_dump_json` instead.', category=None) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1298 def json( # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1299 self,
1300 *,
1301 include: IncEx | None = None,
1302 exclude: IncEx | None = None,
1303 by_alias: bool = False,
1304 exclude_unset: bool = False,
1305 exclude_defaults: bool = False,
1306 exclude_none: bool = False,
1307 encoder: Callable[[Any], Any] | None = PydanticUndefined, # type: ignore[assignment]
1308 models_as_dict: bool = PydanticUndefined, # type: ignore[assignment]
1309 **dumps_kwargs: Any,
1310 ) -> str:
1311 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1312 'The `json` method is deprecated; use `model_dump_json` instead.',
1313 category=PydanticDeprecatedSince20,
1314 stacklevel=2,
1315 )
1316 if encoder is not PydanticUndefined: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1317 raise TypeError('The `encoder` argument is no longer supported; use field serializers instead.') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1318 if models_as_dict is not PydanticUndefined: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1319 raise TypeError('The `models_as_dict` argument is no longer supported; use a model serializer instead.') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1320 if dumps_kwargs: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1321 raise TypeError('`dumps_kwargs` keyword arguments are no longer supported.') 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1322 return self.model_dump_json( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1323 include=include,
1324 exclude=exclude,
1325 by_alias=by_alias,
1326 exclude_unset=exclude_unset,
1327 exclude_defaults=exclude_defaults,
1328 exclude_none=exclude_none,
1329 )
1331 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1332 @typing_extensions.deprecated('The `parse_obj` method is deprecated; use `model_validate` instead.', category=None) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1333 def parse_obj(cls, obj: Any) -> Self: # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1334 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1335 'The `parse_obj` method is deprecated; use `model_validate` instead.',
1336 category=PydanticDeprecatedSince20,
1337 stacklevel=2,
1338 )
1339 return cls.model_validate(obj) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1341 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1342 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1343 'The `parse_raw` method is deprecated; if your data is JSON use `model_validate_json`, ' 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1344 'otherwise load the data then use `model_validate` instead.',
1345 category=None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1346 )
1347 def parse_raw( # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1348 cls,
1349 b: str | bytes, 1cladeFrmnfghJiobjk
1350 *,
1351 content_type: str | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1352 encoding: str = 'utf8', 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1353 proto: DeprecatedParseProtocol | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1354 allow_pickle: bool = False, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1355 ) -> Self: # pragma: no cover 1cladeFrmnfghJiobjk
1356 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1357 'The `parse_raw` method is deprecated; if your data is JSON use `model_validate_json`, ' 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1358 'otherwise load the data then use `model_validate` instead.',
1359 category=PydanticDeprecatedSince20, 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1360 stacklevel=2, 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1361 )
1362 from .deprecated import parse 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1364 try: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1365 obj = parse.load_str_bytes( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1366 b, 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1367 proto=proto, 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1368 content_type=content_type, 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1369 encoding=encoding, 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1370 allow_pickle=allow_pickle, 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1371 )
1372 except (ValueError, TypeError) as exc: 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1373 import json 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1375 # try to match V1
1376 if isinstance(exc, UnicodeDecodeError): 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1377 type_str = 'value_error.unicodedecode'
1378 elif isinstance(exc, json.JSONDecodeError): 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1379 type_str = 'value_error.jsondecode' 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1380 elif isinstance(exc, ValueError):
1381 type_str = 'value_error'
1382 else:
1383 type_str = 'type_error'
1385 # ctx is missing here, but since we've added `input` to the error, we're not pretending it's the same
1386 error: pydantic_core.InitErrorDetails = { 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1387 # The type: ignore on the next line is to ignore the requirement of LiteralString
1388 'type': pydantic_core.PydanticCustomError(type_str, str(exc)), # type: ignore 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1389 'loc': ('__root__',), 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1390 'input': b, 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1391 }
1392 raise pydantic_core.ValidationError.from_exception_data(cls.__name__, [error]) 1CDpuqvcladeGHwxyzmnfghEIsAtBiobjk
1393 return cls.model_validate(obj) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1395 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1396 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1397 'The `parse_file` method is deprecated; load the data from file, then if your data is JSON '
1398 'use `model_validate_json`, otherwise `model_validate` instead.',
1399 category=None,
1400 )
1401 def parse_file( # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1402 cls,
1403 path: str | Path,
1404 *,
1405 content_type: str | None = None,
1406 encoding: str = 'utf8',
1407 proto: DeprecatedParseProtocol | None = None,
1408 allow_pickle: bool = False,
1409 ) -> Self:
1410 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1411 'The `parse_file` method is deprecated; load the data from file, then if your data is JSON '
1412 'use `model_validate_json`, otherwise `model_validate` instead.',
1413 category=PydanticDeprecatedSince20,
1414 stacklevel=2,
1415 )
1416 from .deprecated import parse 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1418 obj = parse.load_file( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1419 path,
1420 proto=proto,
1421 content_type=content_type,
1422 encoding=encoding,
1423 allow_pickle=allow_pickle,
1424 )
1425 return cls.parse_obj(obj) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1427 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1428 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1429 'The `from_orm` method is deprecated; set '
1430 "`model_config['from_attributes']=True` and use `model_validate` instead.",
1431 category=None,
1432 )
1433 def from_orm(cls, obj: Any) -> Self: # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1434 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1435 'The `from_orm` method is deprecated; set '
1436 "`model_config['from_attributes']=True` and use `model_validate` instead.",
1437 category=PydanticDeprecatedSince20,
1438 stacklevel=2,
1439 )
1440 if not cls.model_config.get('from_attributes', None): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1441 raise PydanticUserError( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1442 'You must set the config attribute `from_attributes=True` to use from_orm', code=None
1443 )
1444 return cls.model_validate(obj) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1446 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1447 @typing_extensions.deprecated('The `construct` method is deprecated; use `model_construct` instead.', category=None) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1448 def construct(cls, _fields_set: set[str] | None = None, **values: Any) -> Self: # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1449 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1450 'The `construct` method is deprecated; use `model_construct` instead.',
1451 category=PydanticDeprecatedSince20,
1452 stacklevel=2,
1453 )
1454 return cls.model_construct(_fields_set=_fields_set, **values) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1456 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1457 'The `copy` method is deprecated; use `model_copy` instead. ' 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1458 'See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.',
1459 category=None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1460 )
1461 def copy( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1462 self,
1463 *,
1464 include: AbstractSetIntStr | MappingIntStrAny | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1465 exclude: AbstractSetIntStr | MappingIntStrAny | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1466 update: Dict[str, Any] | None = None, # noqa UP006 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1467 deep: bool = False, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1468 ) -> Self: # pragma: no cover 1cladeFrmnfghJiobjk
1469 """Returns a copy of the model.
1471 !!! warning "Deprecated"
1472 This method is now deprecated; use `model_copy` instead.
1474 If you need `include` or `exclude`, use:
1476 ```python {test="skip" lint="skip"}
1477 data = self.model_dump(include=include, exclude=exclude, round_trip=True)
1478 data = {**data, **(update or {})}
1479 copied = self.model_validate(data)
1480 ```
1482 Args:
1483 include: Optional set or mapping specifying which fields to include in the copied model.
1484 exclude: Optional set or mapping specifying which fields to exclude in the copied model.
1485 update: Optional dictionary of field-value pairs to override field values in the copied model.
1486 deep: If True, the values of fields that are Pydantic models will be deep-copied.
1488 Returns:
1489 A copy of the model with included, excluded and updated fields as specified.
1490 """
1491 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1492 'The `copy` method is deprecated; use `model_copy` instead. ' 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1493 'See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.',
1494 category=PydanticDeprecatedSince20, 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1495 stacklevel=2, 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1496 )
1497 from .deprecated import copy_internals 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1499 values = dict( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1500 copy_internals._iter( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1501 self, to_dict=False, by_alias=False, include=include, exclude=exclude, exclude_unset=False 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1502 ),
1503 **(update or {}), 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1504 )
1505 if self.__pydantic_private__ is None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1506 private = None 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1507 else:
1508 private = {k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined} 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1510 if self.__pydantic_extra__ is None: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1511 extra: dict[str, Any] | None = None 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1512 else:
1513 extra = self.__pydantic_extra__.copy() 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1514 for k in list(self.__pydantic_extra__): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1515 if k not in values: # k was in the exclude 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1516 extra.pop(k)
1517 for k in list(values): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1518 if k in self.__pydantic_extra__: # k must have come from extra 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1519 extra[k] = values.pop(k) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1521 # new `__pydantic_fields_set__` can have unset optional fields with a set value in `update` kwarg
1522 if update: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1523 fields_set = self.__pydantic_fields_set__ | update.keys() 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1524 else:
1525 fields_set = set(self.__pydantic_fields_set__) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1527 # removing excluded fields from `__pydantic_fields_set__`
1528 if exclude: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1529 fields_set -= set(exclude) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1531 return copy_internals._copy_and_set_values(self, values, fields_set, extra, private, deep=deep) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1533 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1534 @typing_extensions.deprecated('The `schema` method is deprecated; use `model_json_schema` instead.', category=None) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1535 def schema( # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1536 cls, by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE
1537 ) -> Dict[str, Any]: # noqa UP006
1538 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1539 'The `schema` method is deprecated; use `model_json_schema` instead.',
1540 category=PydanticDeprecatedSince20,
1541 stacklevel=2,
1542 )
1543 return cls.model_json_schema(by_alias=by_alias, ref_template=ref_template) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1545 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1546 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1547 'The `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.', 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1548 category=None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1549 )
1550 def schema_json( # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1551 cls, *, by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE, **dumps_kwargs: Any 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1552 ) -> str: # pragma: no cover 1cladeFrmnfghJiobjk
1553 warnings.warn(
1554 'The `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.',
1555 category=PydanticDeprecatedSince20,
1556 stacklevel=2,
1557 )
1558 import json
1560 from .deprecated.json import pydantic_encoder
1562 return json.dumps(
1563 cls.model_json_schema(by_alias=by_alias, ref_template=ref_template),
1564 default=pydantic_encoder,
1565 **dumps_kwargs,
1566 )
1568 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1569 @typing_extensions.deprecated('The `validate` method is deprecated; use `model_validate` instead.', category=None) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1570 def validate(cls, value: Any) -> Self: # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1571 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1572 'The `validate` method is deprecated; use `model_validate` instead.',
1573 category=PydanticDeprecatedSince20,
1574 stacklevel=2,
1575 )
1576 return cls.model_validate(value) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1578 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1579 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1580 'The `update_forward_refs` method is deprecated; use `model_rebuild` instead.',
1581 category=None,
1582 )
1583 def update_forward_refs(cls, **localns: Any) -> None: # noqa: D102 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1584 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1585 'The `update_forward_refs` method is deprecated; use `model_rebuild` instead.',
1586 category=PydanticDeprecatedSince20,
1587 stacklevel=2,
1588 )
1589 if localns: # pragma: no cover 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1590 raise TypeError('`localns` arguments are not longer accepted.')
1591 cls.model_rebuild(force=True) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1593 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1594 'The private method `_iter` will be removed and should no longer be used.', category=None
1595 )
1596 def _iter(self, *args: Any, **kwargs: Any) -> Any: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1597 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1598 'The private method `_iter` will be removed and should no longer be used.',
1599 category=PydanticDeprecatedSince20,
1600 stacklevel=2,
1601 )
1602 from .deprecated import copy_internals 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1604 return copy_internals._iter(self, *args, **kwargs) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1606 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1607 'The private method `_copy_and_set_values` will be removed and should no longer be used.',
1608 category=None,
1609 )
1610 def _copy_and_set_values(self, *args: Any, **kwargs: Any) -> Any: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1611 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1612 'The private method `_copy_and_set_values` will be removed and should no longer be used.',
1613 category=PydanticDeprecatedSince20,
1614 stacklevel=2,
1615 )
1616 from .deprecated import copy_internals 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1618 return copy_internals._copy_and_set_values(self, *args, **kwargs) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1620 @classmethod 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1621 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1622 'The private method `_get_value` will be removed and should no longer be used.',
1623 category=None,
1624 )
1625 def _get_value(cls, *args: Any, **kwargs: Any) -> Any: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1626 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1627 'The private method `_get_value` will be removed and should no longer be used.',
1628 category=PydanticDeprecatedSince20,
1629 stacklevel=2,
1630 )
1631 from .deprecated import copy_internals 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1633 return copy_internals._get_value(cls, *args, **kwargs) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1635 @typing_extensions.deprecated( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1636 'The private method `_calculate_keys` will be removed and should no longer be used.',
1637 category=None,
1638 )
1639 def _calculate_keys(self, *args: Any, **kwargs: Any) -> Any: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1640 warnings.warn( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1641 'The private method `_calculate_keys` will be removed and should no longer be used.',
1642 category=PydanticDeprecatedSince20,
1643 stacklevel=2,
1644 )
1645 from .deprecated import copy_internals 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1647 return copy_internals._calculate_keys(self, *args, **kwargs) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1650ModelT = TypeVar('ModelT', bound=BaseModel) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1653@overload 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1654def create_model( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1655 model_name: str, 1cladeFrmnfghJiobjk
1656 /,
1657 *,
1658 __config__: ConfigDict | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1659 __doc__: str | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1660 __base__: None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1661 __module__: str = __name__, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1662 __validators__: dict[str, Callable[..., Any]] | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1663 __cls_kwargs__: dict[str, Any] | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1664 **field_definitions: Any | tuple[str, Any], 1cladeFrmnfghJiobjk
1665) -> type[BaseModel]: ... 1cladeFrmnfghJiobjk
1668@overload 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1669def create_model( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1670 model_name: str, 1cladeFrmnfghJiobjk
1671 /,
1672 *,
1673 __config__: ConfigDict | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1674 __doc__: str | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1675 __base__: type[ModelT] | tuple[type[ModelT], ...], 1cladeFrmnfghJiobjk
1676 __module__: str = __name__, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1677 __validators__: dict[str, Callable[..., Any]] | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1678 __cls_kwargs__: dict[str, Any] | None = None, 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1679 **field_definitions: Any | tuple[str, Any], 1cladeFrmnfghJiobjk
1680) -> type[ModelT]: ... 1cladeFrmnfghJiobjk
1683def create_model( # noqa: C901 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1684 model_name: str,
1685 /,
1686 *,
1687 __config__: ConfigDict | None = None,
1688 __doc__: str | None = None,
1689 __base__: type[ModelT] | tuple[type[ModelT], ...] | None = None,
1690 __module__: str | None = None,
1691 __validators__: dict[str, Callable[..., Any]] | None = None,
1692 __cls_kwargs__: dict[str, Any] | None = None,
1693 # TODO PEP 747: replace `Any` by the TypeForm:
1694 **field_definitions: Any | tuple[str, Any],
1695) -> type[ModelT]:
1696 """!!! abstract "Usage Documentation"
1697 [Dynamic Model Creation](../concepts/models.md#dynamic-model-creation)
1699 Dynamically creates and returns a new Pydantic model, in other words, `create_model` dynamically creates a
1700 subclass of [`BaseModel`][pydantic.BaseModel].
1702 Args:
1703 model_name: The name of the newly created model.
1704 __config__: The configuration of the new model.
1705 __doc__: The docstring of the new model.
1706 __base__: The base class or classes for the new model.
1707 __module__: The name of the module that the model belongs to;
1708 if `None`, the value is taken from `sys._getframe(1)`
1709 __validators__: A dictionary of methods that validate fields. The keys are the names of the validation methods to
1710 be added to the model, and the values are the validation methods themselves. You can read more about functional
1711 validators [here](https://docs.pydantic.dev/2.9/concepts/validators/#field-validators).
1712 __cls_kwargs__: A dictionary of keyword arguments for class creation, such as `metaclass`.
1713 **field_definitions: Field definitions of the new model. Either:
1715 - a single element, representing the type annotation of the field.
1716 - a two-tuple, the first element being the type and the second element the assigned value
1717 (either a default or the [`Field()`][pydantic.Field] function).
1719 Returns:
1720 The new [model][pydantic.BaseModel].
1722 Raises:
1723 PydanticUserError: If `__base__` and `__config__` are both passed.
1724 """
1725 if __base__ is None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1726 __base__ = (cast('type[ModelT]', BaseModel),) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1727 elif not isinstance(__base__, tuple): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1728 __base__ = (__base__,) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1730 __cls_kwargs__ = __cls_kwargs__ or {} 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1732 fields: dict[str, Any] = {} 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1733 annotations: dict[str, Any] = {} 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1735 for f_name, f_def in field_definitions.items(): 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1736 if isinstance(f_def, tuple): 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1737 if len(f_def) != 2: 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1738 raise PydanticUserError( 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1739 f'Field definition for {f_name!r} should a single element representing the type or a two-tuple, the first element '
1740 'being the type and the second element the assigned value (either a default or the `Field()` function).',
1741 code='create-model-field-definitions',
1742 )
1744 annotations[f_name] = f_def[0] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1745 fields[f_name] = f_def[1] 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1746 else:
1747 annotations[f_name] = f_def 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1749 if __module__ is None: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1750 f = sys._getframe(1) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1751 __module__ = f.f_globals['__name__'] 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1753 namespace: dict[str, Any] = {'__annotations__': annotations, '__module__': __module__} 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1754 if __doc__: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1755 namespace.update({'__doc__': __doc__}) 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1756 if __validators__: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1757 namespace.update(__validators__) 1CpqcaEstib
1758 namespace.update(fields) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1759 if __config__: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1760 namespace['model_config'] = __config__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1761 resolved_bases = types.resolve_bases(__base__) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1762 meta, ns, kwds = types.prepare_class(model_name, resolved_bases, kwds=__cls_kwargs__) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1763 if resolved_bases is not __base__: 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1764 ns['__orig_bases__'] = __base__ 1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk
1765 namespace.update(ns) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1767 return meta( 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk
1768 model_name,
1769 resolved_bases,
1770 namespace,
1771 __pydantic_reset_parent_namespace__=False,
1772 _create_model_module=__module__,
1773 **kwds,
1774 )
1777__getattr__ = getattr_migration(__name__) 1CDpuqvcladeFrGHwxyzmnfghJEIsAtBiobjk