Coverage for pydantic/main.py: 98.14%

1"""Logic for creating models.""" 

2 

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 

6 

7from __future__ import annotations as _annotations 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

8 

9import operator 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

10import sys 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

11import types 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

12import typing 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

13import warnings 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

14from collections.abc import Generator, Mapping 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

15from copy import copy, deepcopy 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

16from functools import cached_property 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

17from typing import ( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

18 TYPE_CHECKING, 

19 Any, 

20 Callable, 

21 ClassVar, 

22 Dict, 

23 Literal, 

24 TypeVar, 

25 Union, 

26 cast, 

27 overload, 

28) 

29 

30import pydantic_core 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

31import typing_extensions 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

32from pydantic_core import PydanticUndefined, ValidationError 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

33from typing_extensions import Self, TypeAlias, Unpack 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

34 

35from . import PydanticDeprecatedSince20, PydanticDeprecatedSince211 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

36from ._internal import ( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

50from .aliases import AliasChoices, AliasPath 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

51from .annotated_handlers import GetCoreSchemaHandler, GetJsonSchemaHandler 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

52from .config import ConfigDict 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

53from .errors import PydanticUndefinedAnnotation, PydanticUserError 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

54from .json_schema import DEFAULT_REF_TEMPLATE, GenerateJsonSchema, JsonSchemaMode, JsonSchemaValue, model_json_schema 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

55from .plugin._schema_validator import PluggableSchemaValidator 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

56 

57if TYPE_CHECKING: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

58 from inspect import Signature 

59 from pathlib import Path 

60 

61 from pydantic_core import CoreSchema, SchemaSerializer, SchemaValidator 

62 

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 1 ctx1r

67else: 

68 # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915 

69 # and https://youtrack.jetbrains.com/issue/PY-51428 

70 DeprecationWarning = PydanticDeprecatedSince20 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

71 

72__all__ = 'BaseModel', 'create_model' 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

73 

74# Keep these type aliases available at runtime: 

75TupleGenerator: TypeAlias = Generator[tuple[str, Any], None, None] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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]]] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

80 

81_object_setattr = _model_construction.object_setattr 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

82 

83 

84def _check_frozen(model_cls: type[BaseModel], name: str, value: Any) -> None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

85 if model_cls.model_config.get('frozen'): 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

86 error_type = 'frozen_instance' 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

87 elif getattr(model_cls.__pydantic_fields__.get(name), 'frozen', False): 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

88 error_type = 'frozen_field' 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

89 else: 

90 return 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

91 

92 raise ValidationError.from_exception_data( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

93 model_cls.__name__, [{'type': error_type, 'loc': (name,), 'input': value}] 

94 ) 

95 

96 

97def _model_field_setattr_handler(model: BaseModel, name: str, val: Any) -> None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

98 model.__dict__[name] = val 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

99 model.__pydantic_fields_set__.add(name) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

100 

101 

102def _private_setattr_handler(model: BaseModel, name: str, val: Any) -> None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

103 if getattr(model, '__pydantic_private__', None) is None: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

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__', {}) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

109 model.__pydantic_private__[name] = val # pyright: ignore[reportOptionalSubscript] 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

110 

111 

112_SIMPLE_SETATTR_HANDLERS: Mapping[str, Callable[[BaseModel, str, Any], None]] = { 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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} 

119 

120 

121class BaseModel(metaclass=_model_construction.ModelMetaclass): 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

122 """!!! abstract "Usage Documentation" 

123 [Models](../concepts/models.md) 

124 

125 A base class for creating Pydantic models. 

126 

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. 

131 

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. 

144 

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. 

147 

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 """ 

153 

154 # Note: Many of the below class vars are defined in the metaclass, but we define them here for type checking purposes. 

155 

156 model_config: ClassVar[ConfigDict] = ConfigDict() 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

157 """ 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

158 Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict]. 

159 """ 

160 

161 __class_vars__: ClassVar[set[str]] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

162 """The names of the class variables defined on the model.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

163 

164 __private_attributes__: ClassVar[Dict[str, ModelPrivateAttr]] # noqa: UP006 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

165 """Metadata about the private attributes of the model.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

166 

167 __signature__: ClassVar[Signature] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

168 """The synthesized `__init__` [`Signature`][inspect.Signature] of the model.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

169 

170 __pydantic_complete__: ClassVar[bool] = False 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

171 """Whether model building is completed, or if there are still undefined fields.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

172 

173 __pydantic_core_schema__: ClassVar[CoreSchema] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

174 """The core schema of the model.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

175 

176 __pydantic_custom_init__: ClassVar[bool] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

177 """Whether the model has a custom `__init__` method.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

178 

179 # Must be set for `GenerateSchema.model_schema` to work for a plain `BaseModel` annotation. 

180 __pydantic_decorators__: ClassVar[_decorators.DecoratorInfos] = _decorators.DecoratorInfos() 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

181 """Metadata containing the decorators defined on the model. 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

182 This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.""" 

183 

184 __pydantic_generic_metadata__: ClassVar[_generics.PydanticGenericMetadata] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

185 """Metadata for generic models; contains data used for a similar purpose to 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

186 __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.""" 

187 

188 __pydantic_parent_namespace__: ClassVar[Dict[str, Any] | None] = None # noqa: UP006 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

189 """Parent namespace of the model, used for automatic rebuilding of models.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

190 

191 __pydantic_post_init__: ClassVar[None | Literal['model_post_init']] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

192 """The name of the post-init method for the model, if defined.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

193 

194 __pydantic_root_model__: ClassVar[bool] = False 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

195 """Whether the model is a [`RootModel`][pydantic.root_model.RootModel].""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

196 

197 __pydantic_serializer__: ClassVar[SchemaSerializer] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

198 """The `pydantic-core` `SchemaSerializer` used to dump instances of the model.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

199 

200 __pydantic_validator__: ClassVar[SchemaValidator | PluggableSchemaValidator] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

201 """The `pydantic-core` `SchemaValidator` used to validate instances of the model.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

202 

203 __pydantic_fields__: ClassVar[Dict[str, FieldInfo]] # noqa: UP006 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

204 """A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects. 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

205 This replaces `Model.__fields__` from Pydantic V1. 

206 """ 

207 

208 __pydantic_setattr_handlers__: ClassVar[Dict[str, Callable[[BaseModel, str, Any], None]]] # noqa: UP006 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

209 """`__setattr__` handlers. Memoizing the handlers leads to a dramatic performance improvement in `__setattr__`""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

210 

211 __pydantic_computed_fields__: ClassVar[Dict[str, ComputedFieldInfo]] # noqa: UP006 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

212 """A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

213 

214 __pydantic_extra__: dict[str, Any] | None = _model_construction.NoInitField(init=False) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

215 """A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra] is set to `'allow'`.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

216 

217 __pydantic_fields_set__: set[str] = _model_construction.NoInitField(init=False) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

218 """The names of fields explicitly set during instantiation.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

219 

220 __pydantic_private__: dict[str, Any] | None = _model_construction.NoInitField(init=False) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

221 """Values of private attributes set on the model instance.""" 34 ctx1puqvcladerwxyzmnfghNOJKLMsAtBiobjk

222 

223 if not TYPE_CHECKING: 223 ↛ 241line 223 didn't jump to line 241 because the condition on line 223 was always true42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

236 'Pydantic models should inherit from BaseModel, BaseModel cannot be instantiated directly', 

237 val_or_ser='serializer', 

238 code='base-model-instantiated', 

239 ) 

240 

241 __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

242 

243 def __init__(self, /, **data: Any) -> None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

244 """Create a new model by parsing and validating input data from keyword arguments. 

245 

246 Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be 

247 validated to form a valid model. 

248 

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 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

253 validated_self = self.__pydantic_validator__.validate_python(data, self_instance=self) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

254 if self is not validated_self: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

255 warnings.warn( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

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 ) 

261 

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] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

264 

265 @_utils.deprecated_instance_property 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

266 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

267 def model_fields(cls) -> dict[str, FieldInfo]: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

268 """A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances. 

269 

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__', {}) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

275 

276 @_utils.deprecated_instance_property 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

277 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

278 def model_computed_fields(cls) -> dict[str, ComputedFieldInfo]: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

279 """A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances. 

280 

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__', {}) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

286 

287 @property 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

288 def model_extra(self) -> dict[str, Any] | None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

289 """Get extra fields set during validation. 

290 

291 Returns: 

292 A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. 

293 """ 

294 return self.__pydantic_extra__ 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

295 

296 @property 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

297 def model_fields_set(self) -> set[str]: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

298 """Returns the set of fields that have been explicitly set on this model instance. 

299 

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__ 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

305 

306 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

307 def model_construct(cls, _fields_set: set[str] | None = None, **values: Any) -> Self: # noqa: C901 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

308 """Creates a new instance of the `Model` class with validated data. 

309 

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. 

312 

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. 

319 

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. 

325 

326 Returns: 

327 A new instance of the `Model` class with validated data. 

328 """ 

329 m = cls.__new__(cls) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

330 fields_values: dict[str, Any] = {} 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

331 fields_set = set() 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

332 

333 for name, field in cls.__pydantic_fields__.items(): 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

334 if field.alias is not None and field.alias in values: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

335 fields_values[name] = values.pop(field.alias) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

336 fields_set.add(name) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

337 

338 if (name not in fields_set) and (field.validation_alias is not None): 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

339 validation_aliases: list[str | AliasPath] = ( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

340 field.validation_alias.choices 

341 if isinstance(field.validation_alias, AliasChoices) 

342 else [field.validation_alias] 

343 ) 

344 

345 for alias in validation_aliases: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

346 if isinstance(alias, str) and alias in values: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

347 fields_values[name] = values.pop(alias) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

348 fields_set.add(name) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

349 break 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

350 elif isinstance(alias, AliasPath): 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

351 value = alias.search_dict_for_path(values) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

352 if value is not PydanticUndefined: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

353 fields_values[name] = value 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

354 fields_set.add(name) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

355 break 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

356 

357 if name not in fields_set: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

358 if name in values: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

359 fields_values[name] = values.pop(name) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

360 fields_set.add(name) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

361 elif not field.is_required(): 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

362 fields_values[name] = field.get_default(call_default_factory=True, validated_data=fields_values) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

363 if _fields_set is None: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

364 _fields_set = fields_set 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

365 

366 _extra: dict[str, Any] | None = values if cls.model_config.get('extra') == 'allow' else None 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

367 _object_setattr(m, '__dict__', fields_values) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

368 _object_setattr(m, '__pydantic_fields_set__', _fields_set) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

369 if not cls.__pydantic_root_model__: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

370 _object_setattr(m, '__pydantic_extra__', _extra) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

371 

372 if cls.__pydantic_post_init__: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

373 m.model_post_init(None) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

374 # update private attributes with values set 

375 if hasattr(m, '__pydantic_private__') and m.__pydantic_private__ is not None: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

376 for k, v in values.items(): 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

377 if k in m.__private_attributes__: 377 ↛ 376line 377 didn't jump to line 376 because the condition on line 377 was always true35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

378 m.__pydantic_private__[k] = v 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

379 

380 elif not cls.__pydantic_root_model__: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

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) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

384 

385 return m 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

386 

387 def model_copy(self, *, update: Mapping[str, Any] | None = None, deep: bool = False) -> Self: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

388 """!!! abstract "Usage Documentation" 

389 [`model_copy`](../concepts/serialization.md#model_copy) 

390 

391 Returns a copy of the model. 

392 

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]). 

397 

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. 

402 

403 Returns: 

404 New model instance. 

405 """ 

406 copied = self.__deepcopy__() if deep else self.__copy__() 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

407 if update: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

408 if self.model_config.get('extra') == 'allow': 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

409 for k, v in update.items(): 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

410 if k in self.__pydantic_fields__: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

411 copied.__dict__[k] = v 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

412 else: 

413 if copied.__pydantic_extra__ is None: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

414 copied.__pydantic_extra__ = {} 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

415 copied.__pydantic_extra__[k] = v 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

416 else: 

417 copied.__dict__.update(update) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

418 copied.__pydantic_fields_set__.update(update.keys()) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

419 return copied 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

420 

421 def model_dump( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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) 

439 

440 Generate a dictionary representation of the model, optionally specifying which fields to include or exclude. 

441 

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. 

459 

460 Returns: 

461 A dictionary representation of the model. 

462 """ 

463 return self.__pydantic_serializer__.to_python( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

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 ) 

478 

479 def model_dump_json( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

480 self, 

481 *, 

482 indent: int | None = None, 

483 include: IncEx | None = None, 

484 exclude: IncEx | None = None, 

485 context: Any | None = None, 

486 by_alias: bool | None = None, 

487 exclude_unset: bool = False, 

488 exclude_defaults: bool = False, 

489 exclude_none: bool = False, 

490 round_trip: bool = False, 

491 warnings: bool | Literal['none', 'warn', 'error'] = True, 

492 fallback: Callable[[Any], Any] | None = None, 

493 serialize_as_any: bool = False, 

494 ) -> str: 

495 """!!! abstract "Usage Documentation" 

496 [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json) 

497 

498 Generates a JSON representation of the model using Pydantic's `to_json` method. 

499 

500 Args: 

501 indent: Indentation to use in the JSON output. If None is passed, the output will be compact. 

502 include: Field(s) to include in the JSON output. 

503 exclude: Field(s) to exclude from the JSON output. 

504 context: Additional context to pass to the serializer. 

505 by_alias: Whether to serialize using field aliases. 

506 exclude_unset: Whether to exclude fields that have not been explicitly set. 

507 exclude_defaults: Whether to exclude fields that are set to their default value. 

508 exclude_none: Whether to exclude fields that have a value of `None`. 

509 round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T]. 

510 warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, 

511 "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError]. 

512 fallback: A function to call when an unknown value is encountered. If not provided, 

513 a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised. 

514 serialize_as_any: Whether to serialize fields with duck-typing serialization behavior. 

515 

516 Returns: 

517 A JSON string representation of the model. 

518 """ 

519 return self.__pydantic_serializer__.to_json( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

520 self, 

521 indent=indent, 

522 include=include, 

523 exclude=exclude, 

524 context=context, 

525 by_alias=by_alias, 

526 exclude_unset=exclude_unset, 

527 exclude_defaults=exclude_defaults, 

528 exclude_none=exclude_none, 

529 round_trip=round_trip, 

530 warnings=warnings, 

531 fallback=fallback, 

532 serialize_as_any=serialize_as_any, 

533 ).decode() 

534 

535 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

536 def model_json_schema( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

537 cls, 

538 by_alias: bool = True, 

539 ref_template: str = DEFAULT_REF_TEMPLATE, 

540 schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema, 

541 mode: JsonSchemaMode = 'validation', 

542 ) -> dict[str, Any]: 

543 """Generates a JSON schema for a model class. 

544 

545 Args: 

546 by_alias: Whether to use attribute aliases or not. 

547 ref_template: The reference template. 

548 schema_generator: To override the logic used to generate the JSON schema, as a subclass of 

549 `GenerateJsonSchema` with your desired modifications 

550 mode: The mode in which to generate the schema. 

551 

552 Returns: 

553 The JSON schema for the given model class. 

554 """ 

555 return model_json_schema( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

556 cls, by_alias=by_alias, ref_template=ref_template, schema_generator=schema_generator, mode=mode 

557 ) 

558 

559 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

560 def model_parametrized_name(cls, params: tuple[type[Any], ...]) -> str: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

561 """Compute the class name for parametrizations of generic classes. 

562 

563 This method can be overridden to achieve a custom naming scheme for generic BaseModels. 

564 

565 Args: 

566 params: Tuple of types of the class. Given a generic class 

567 `Model` with 2 type variables and a concrete model `Model[str, int]`, 

568 the value `(str, int)` would be passed to `params`. 

569 

570 Returns: 

571 String representing the new class where `params` are passed to `cls` as type variables. 

572 

573 Raises: 

574 TypeError: Raised when trying to generate concrete names for non-generic models. 

575 """ 

576 if not issubclass(cls, typing.Generic): 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

577 raise TypeError('Concrete names should only be generated for generic models.') 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

578 

579 # Any strings received should represent forward references, so we handle them specially below. 

580 # If we eventually move toward wrapping them in a ForwardRef in __class_getitem__ in the future, 

581 # we may be able to remove this special case. 

582 param_names = [param if isinstance(param, str) else _repr.display_as_type(param) for param in params] 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

583 params_component = ', '.join(param_names) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

584 return f'{cls.__name__}[{params_component}]' 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

585 

586 def model_post_init(self, context: Any, /) -> None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

587 """Override this method to perform additional initialization after `__init__` and `model_construct`. 

588 This is useful if you want to do some validation that requires the entire model to be initialized. 

589 """ 

590 pass 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

591 

592 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

593 def model_rebuild( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

594 cls, 

595 *, 

596 force: bool = False, 

597 raise_errors: bool = True, 

598 _parent_namespace_depth: int = 2, 

599 _types_namespace: MappingNamespace | None = None, 

600 ) -> bool | None: 

601 """Try to rebuild the pydantic-core schema for the model. 

602 

603 This may be necessary when one of the annotations is a ForwardRef which could not be resolved during 

604 the initial attempt to build the schema, and automatic rebuilding fails. 

605 

606 Args: 

607 force: Whether to force the rebuilding of the model schema, defaults to `False`. 

608 raise_errors: Whether to raise errors, defaults to `True`. 

609 _parent_namespace_depth: The depth level of the parent namespace, defaults to 2. 

610 _types_namespace: The types namespace, defaults to `None`. 

611 

612 Returns: 

613 Returns `None` if the schema is already "complete" and rebuilding was not required. 

614 If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. 

615 """ 

616 if not force and cls.__pydantic_complete__: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

617 return None 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

618 

619 for attr in ('__pydantic_core_schema__', '__pydantic_validator__', '__pydantic_serializer__'): 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

620 if attr in cls.__dict__ and not isinstance(getattr(cls, attr), _mock_val_ser.MockValSer): 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

621 # Deleting the validator/serializer is necessary as otherwise they can get reused in 

622 # pydantic-core. We do so only if they aren't mock instances, otherwise — as `model_rebuild()` 

623 # isn't thread-safe — concurrent model instantiations can lead to the parent validator being used. 

624 # Same applies for the core schema that can be reused in schema generation. 

625 delattr(cls, attr) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

626 

627 cls.__pydantic_complete__ = False 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

628 

629 if _types_namespace is not None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

630 rebuild_ns = _types_namespace 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

631 elif _parent_namespace_depth > 0: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

632 rebuild_ns = _typing_extra.parent_frame_namespace(parent_depth=_parent_namespace_depth, force=True) or {} 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

633 else: 

634 rebuild_ns = {} 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

635 

636 parent_ns = _model_construction.unpack_lenient_weakvaluedict(cls.__pydantic_parent_namespace__) or {} 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

637 

638 ns_resolver = _namespace_utils.NsResolver( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

639 parent_namespace={**rebuild_ns, **parent_ns}, 

640 ) 

641 

642 if not cls.__pydantic_fields_complete__: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

643 typevars_map = _generics.get_model_typevars_map(cls) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

644 try: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

645 cls.__pydantic_fields__ = _fields.rebuild_model_fields( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

646 cls, 

647 ns_resolver=ns_resolver, 

648 typevars_map=typevars_map, 

649 ) 

650 except NameError as e: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

651 exc = PydanticUndefinedAnnotation.from_name_error(e) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

652 _mock_val_ser.set_model_mocks(cls, f'`{exc.name}`') 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

653 if raise_errors: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

654 raise exc from e 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

655 

656 if not raise_errors and not cls.__pydantic_fields_complete__: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

657 # No need to continue with schema gen, it is guaranteed to fail 

658 return False 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

659 

660 assert cls.__pydantic_fields_complete__ 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

661 

662 return _model_construction.complete_model_class( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

663 cls, 

664 _config.ConfigWrapper(cls.model_config, check=False), 

665 raise_errors=raise_errors, 

666 ns_resolver=ns_resolver, 

667 ) 

668 

669 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

670 def model_validate( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

671 cls, 

672 obj: Any, 

673 *, 

674 strict: bool | None = None, 

675 from_attributes: bool | None = None, 

676 context: Any | None = None, 

677 by_alias: bool | None = None, 

678 by_name: bool | None = None, 

679 ) -> Self: 

680 """Validate a pydantic model instance. 

681 

682 Args: 

683 obj: The object to validate. 

684 strict: Whether to enforce types strictly. 

685 from_attributes: Whether to extract data from object attributes. 

686 context: Additional context to pass to the validator. 

687 by_alias: Whether to use the field's alias when validating against the provided input data. 

688 by_name: Whether to use the field's name when validating against the provided input data. 

689 

690 Raises: 

691 ValidationError: If the object could not be validated. 

692 

693 Returns: 

694 The validated model instance. 

695 """ 

696 # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks 

697 __tracebackhide__ = True 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

698 

699 if by_alias is False and by_name is not True: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

700 raise PydanticUserError( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

701 'At least one of `by_alias` or `by_name` must be set to True.', 

702 code='validate-by-alias-and-name-false', 

703 ) 

704 

705 return cls.__pydantic_validator__.validate_python( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

706 obj, strict=strict, from_attributes=from_attributes, context=context, by_alias=by_alias, by_name=by_name 

707 ) 

708 

709 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

710 def model_validate_json( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

711 cls, 

712 json_data: str | bytes | bytearray, 

713 *, 

714 strict: bool | None = None, 

715 context: Any | None = None, 

716 by_alias: bool | None = None, 

717 by_name: bool | None = None, 

718 ) -> Self: 

719 """!!! abstract "Usage Documentation" 

720 [JSON Parsing](../concepts/json.md#json-parsing) 

721 

722 Validate the given JSON data against the Pydantic model. 

723 

724 Args: 

725 json_data: The JSON data to validate. 

726 strict: Whether to enforce types strictly. 

727 context: Extra variables to pass to the validator. 

728 by_alias: Whether to use the field's alias when validating against the provided input data. 

729 by_name: Whether to use the field's name when validating against the provided input data. 

730 

731 Returns: 

732 The validated Pydantic model. 

733 

734 Raises: 

735 ValidationError: If `json_data` is not a JSON string or the object could not be validated. 

736 """ 

737 # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks 

738 __tracebackhide__ = True 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

739 

740 if by_alias is False and by_name is not True: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

741 raise PydanticUserError( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

742 'At least one of `by_alias` or `by_name` must be set to True.', 

743 code='validate-by-alias-and-name-false', 

744 ) 

745 

746 return cls.__pydantic_validator__.validate_json( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

747 json_data, strict=strict, context=context, by_alias=by_alias, by_name=by_name 

748 ) 

749 

750 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

751 def model_validate_strings( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

752 cls, 

753 obj: Any, 

754 *, 

755 strict: bool | None = None, 

756 context: Any | None = None, 

757 by_alias: bool | None = None, 

758 by_name: bool | None = None, 

759 ) -> Self: 

760 """Validate the given object with string data against the Pydantic model. 

761 

762 Args: 

763 obj: The object containing string data to validate. 

764 strict: Whether to enforce types strictly. 

765 context: Extra variables to pass to the validator. 

766 by_alias: Whether to use the field's alias when validating against the provided input data. 

767 by_name: Whether to use the field's name when validating against the provided input data. 

768 

769 Returns: 

770 The validated Pydantic model. 

771 """ 

772 # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks 

773 __tracebackhide__ = True 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

774 

775 if by_alias is False and by_name is not True: 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

776 raise PydanticUserError( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

777 'At least one of `by_alias` or `by_name` must be set to True.', 

778 code='validate-by-alias-and-name-false', 

779 ) 

780 

781 return cls.__pydantic_validator__.validate_strings( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

782 obj, strict=strict, context=context, by_alias=by_alias, by_name=by_name 

783 ) 

784 

785 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

786 def __get_pydantic_core_schema__(cls, source: type[BaseModel], handler: GetCoreSchemaHandler, /) -> CoreSchema: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

787 # This warning is only emitted when calling `super().__get_pydantic_core_schema__` from a model subclass. 

788 # In the generate schema logic, this method (`BaseModel.__get_pydantic_core_schema__`) is special cased to 

789 # *not* be called if not overridden. 

790 warnings.warn( 

791 'The `__get_pydantic_core_schema__` method of the `BaseModel` class is deprecated. If you are calling ' 

792 '`super().__get_pydantic_core_schema__` when overriding the method on a Pydantic model, consider using ' 

793 '`handler(source)` instead. However, note that overriding this method on models can lead to unexpected ' 

794 'side effects.', 

795 PydanticDeprecatedSince211, 

796 stacklevel=2, 

797 ) 

798 # Logic copied over from `GenerateSchema._model_schema`: 

799 schema = cls.__dict__.get('__pydantic_core_schema__') 

800 if schema is not None and not isinstance(schema, _mock_val_ser.MockCoreSchema): 

801 return cls.__pydantic_core_schema__ 

802 

803 return handler(source) 

804 

805 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

806 def __get_pydantic_json_schema__( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

807 cls, 

808 core_schema: CoreSchema, 

809 handler: GetJsonSchemaHandler, 

810 /, 

811 ) -> JsonSchemaValue: 

812 """Hook into generating the model's JSON schema. 

813 

814 Args: 

815 core_schema: A `pydantic-core` CoreSchema. 

816 You can ignore this argument and call the handler with a new CoreSchema, 

817 wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`), 

818 or just call the handler with the original schema. 

819 handler: Call into Pydantic's internal JSON schema generation. 

820 This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema 

821 generation fails. 

822 Since this gets called by `BaseModel.model_json_schema` you can override the 

823 `schema_generator` argument to that function to change JSON schema generation globally 

824 for a type. 

825 

826 Returns: 

827 A JSON schema, as a Python object. 

828 """ 

829 return handler(core_schema) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

830 

831 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

832 def __pydantic_init_subclass__(cls, **kwargs: Any) -> None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

833 """This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` 

834 only after the class is actually fully initialized. In particular, attributes like `model_fields` will 

835 be present when this is called. 

836 

837 This is necessary because `__init_subclass__` will always be called by `type.__new__`, 

838 and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that 

839 `type.__new__` was called in such a manner that the class would already be sufficiently initialized. 

840 

841 This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, 

842 any kwargs passed to the class definition that aren't used internally by pydantic. 

843 

844 Args: 

845 **kwargs: Any keyword arguments passed to the class definition that aren't used internally 

846 by pydantic. 

847 """ 

848 pass 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

849 

850 def __class_getitem__( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk