Coverage for pydantic/main.py: 98.11%

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 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

8 

9import operator 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

10import sys 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

11import types 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

12import typing 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

13import warnings 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

14from collections.abc import Generator, Mapping 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

15from copy import copy, deepcopy 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

16from functools import cached_property 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

17from typing import ( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

31import typing_extensions 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

32from pydantic_core import PydanticUndefined, ValidationError 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

33from typing_extensions import Self, TypeAlias, Unpack 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

34 

35from . import PydanticDeprecatedSince20, PydanticDeprecatedSince211 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

36from ._internal import ( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

50from .aliases import AliasChoices, AliasPath 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

51from .annotated_handlers import GetCoreSchemaHandler, GetJsonSchemaHandler 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

52from .config import ConfigDict 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

53from .errors import PydanticUndefinedAnnotation, PydanticUserError 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

54from .json_schema import DEFAULT_REF_TEMPLATE, GenerateJsonSchema, JsonSchemaMode, JsonSchemaValue, model_json_schema 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

55from .plugin._schema_validator import PluggableSchemaValidator 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

56 

57if TYPE_CHECKING: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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 ctx1o

67else: 

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

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

70 DeprecationWarning = PydanticDeprecatedSince20 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

71 

72__all__ = 'BaseModel', 'create_model' 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

73 

74# Keep these type aliases available at runtime: 

75TupleGenerator: TypeAlias = Generator[tuple[str, Any], None, None] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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]]] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

80 

81_object_setattr = _model_construction.object_setattr 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

82 

83 

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

85 if model_cls.model_config.get('frozen'): 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

86 error_type = 'frozen_instance' 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

87 elif getattr(model_cls.__pydantic_fields__.get(name), 'frozen', False): 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

88 error_type = 'frozen_field' 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

89 else: 

90 return 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

91 

92 raise ValidationError.from_exception_data( 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

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: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

98 model.__dict__[name] = val 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

99 model.__pydantic_fields_set__.add(name) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

100 

101 

102_SIMPLE_SETATTR_HANDLERS: Mapping[str, Callable[[BaseModel, str, Any], None]] = { 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

103 'model_field': _model_field_setattr_handler, 

104 'validate_assignment': lambda model, name, val: model.__pydantic_validator__.validate_assignment(model, name, val), # pyright: ignore[reportAssignmentType] 

105 'private': lambda model, name, val: model.__pydantic_private__.__setitem__(name, val), # pyright: ignore[reportOptionalMemberAccess] 

106 'cached_property': lambda model, name, val: model.__dict__.__setitem__(name, val), 

107 'extra_known': lambda model, name, val: _object_setattr(model, name, val), 

108} 

109 

110 

111class BaseModel(metaclass=_model_construction.ModelMetaclass): 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

112 """!!! abstract "Usage Documentation" 

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

114 

115 A base class for creating Pydantic models. 

116 

117 Attributes: 

118 __class_vars__: The names of the class variables defined on the model. 

119 __private_attributes__: Metadata about the private attributes of the model. 

120 __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model. 

121 

122 __pydantic_complete__: Whether model building is completed, or if there are still undefined fields. 

123 __pydantic_core_schema__: The core schema of the model. 

124 __pydantic_custom_init__: Whether the model has a custom `__init__` function. 

125 __pydantic_decorators__: Metadata containing the decorators defined on the model. 

126 This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1. 

127 __pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to 

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

129 __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models. 

130 __pydantic_post_init__: The name of the post-init method for the model, if defined. 

131 __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel]. 

132 __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model. 

133 __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model. 

134 

135 __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects. 

136 __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects. 

137 

138 __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra] 

139 is set to `'allow'`. 

140 __pydantic_fields_set__: The names of fields explicitly set during instantiation. 

141 __pydantic_private__: Values of private attributes set on the model instance. 

142 """ 

143 

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

145 

146 model_config: ClassVar[ConfigDict] = ConfigDict() 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

147 """ 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

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

149 """ 

150 

151 __class_vars__: ClassVar[set[str]] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

152 """The names of the class variables defined on the model.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

153 

154 __private_attributes__: ClassVar[Dict[str, ModelPrivateAttr]] # noqa: UP006 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

155 """Metadata about the private attributes of the model.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

156 

157 __signature__: ClassVar[Signature] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

158 """The synthesized `__init__` [`Signature`][inspect.Signature] of the model.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

159 

160 __pydantic_complete__: ClassVar[bool] = False 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

161 """Whether model building is completed, or if there are still undefined fields.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

162 

163 __pydantic_core_schema__: ClassVar[CoreSchema] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

164 """The core schema of the model.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

165 

166 __pydantic_custom_init__: ClassVar[bool] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

167 """Whether the model has a custom `__init__` method.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

168 

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

170 __pydantic_decorators__: ClassVar[_decorators.DecoratorInfos] = _decorators.DecoratorInfos() 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

171 """Metadata containing the decorators defined on the model. 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

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

173 

174 __pydantic_generic_metadata__: ClassVar[_generics.PydanticGenericMetadata] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

175 """Metadata for generic models; contains data used for a similar purpose to 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

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

177 

178 __pydantic_parent_namespace__: ClassVar[Dict[str, Any] | None] = None # noqa: UP006 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

179 """Parent namespace of the model, used for automatic rebuilding of models.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

180 

181 __pydantic_post_init__: ClassVar[None | Literal['model_post_init']] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

182 """The name of the post-init method for the model, if defined.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

183 

184 __pydantic_root_model__: ClassVar[bool] = False 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

185 """Whether the model is a [`RootModel`][pydantic.root_model.RootModel].""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

186 

187 __pydantic_serializer__: ClassVar[SchemaSerializer] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

188 """The `pydantic-core` `SchemaSerializer` used to dump instances of the model.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

189 

190 __pydantic_validator__: ClassVar[SchemaValidator | PluggableSchemaValidator] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

191 """The `pydantic-core` `SchemaValidator` used to validate instances of the model.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

192 

193 __pydantic_fields__: ClassVar[Dict[str, FieldInfo]] # noqa: UP006 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

194 """A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects. 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

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

196 """ 

197 

198 __pydantic_setattr_handlers__: ClassVar[Dict[str, Callable[[BaseModel, str, Any], None]]] # noqa: UP006 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

199 """`__setattr__` handlers. Memoizing the handlers leads to a dramatic performance improvement in `__setattr__`""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

200 

201 __pydantic_computed_fields__: ClassVar[Dict[str, ComputedFieldInfo]] # noqa: UP006 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

202 """A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

203 

204 __pydantic_extra__: dict[str, Any] | None = _model_construction.NoInitField(init=False) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

205 """A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra] is set to `'allow'`.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

206 

207 __pydantic_fields_set__: set[str] = _model_construction.NoInitField(init=False) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

208 """The names of fields explicitly set during instantiation.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

209 

210 __pydantic_private__: dict[str, Any] | None = _model_construction.NoInitField(init=False) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

211 """Values of private attributes set on the model instance.""" 31 ctx1mrnsciadotuvwjkefKLGHIJpxqyglbh

212 

213 if not TYPE_CHECKING: 213 ↛ 231line 213 didn't jump to line 231 because the condition on line 213 was always true39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

214 # Prevent `BaseModel` from being instantiated directly 

215 # (defined in an `if not TYPE_CHECKING` block for clarity and to avoid type checking errors): 

216 __pydantic_core_schema__ = _mock_val_ser.MockCoreSchema( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

218 code='base-model-instantiated', 

219 ) 

220 __pydantic_validator__ = _mock_val_ser.MockValSer( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

222 val_or_ser='validator', 

223 code='base-model-instantiated', 

224 ) 

225 __pydantic_serializer__ = _mock_val_ser.MockValSer( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

227 val_or_ser='serializer', 

228 code='base-model-instantiated', 

229 ) 

230 

231 __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

232 

233 def __init__(self, /, **data: Any) -> None: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

235 

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

237 validated to form a valid model. 

238 

239 `self` is explicitly positional-only to allow `self` as a field name. 

240 """ 

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

242 __tracebackhide__ = True 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

243 validated_self = self.__pydantic_validator__.validate_python(data, self_instance=self) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

244 if self is not validated_self: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

245 warnings.warn( 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

246 'A custom validator is returning a value other than `self`.\n' 

247 "Returning anything other than `self` from a top level model validator isn't supported when validating via `__init__`.\n" 

248 'See the `model_validator` docs (https://docs.pydantic.dev/latest/concepts/validators/#model-validators) for more details.', 

249 stacklevel=2, 

250 ) 

251 

252 # The following line sets a flag that we use to determine when `__init__` gets overridden by the user 

253 __init__.__pydantic_base_init__ = True # pyright: ignore[reportFunctionMemberAccess] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

254 

255 @_utils.deprecated_instance_property 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

256 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

257 def model_fields(cls) -> dict[str, FieldInfo]: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

259 

260 !!! warning 

261 Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3. 

262 Instead, you should access this attribute from the model class. 

263 """ 

264 return getattr(cls, '__pydantic_fields__', {}) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

265 

266 @_utils.deprecated_instance_property 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

267 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

268 def model_computed_fields(cls) -> dict[str, ComputedFieldInfo]: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

270 

271 !!! warning 

272 Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3. 

273 Instead, you should access this attribute from the model class. 

274 """ 

275 return getattr(cls, '__pydantic_computed_fields__', {}) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

276 

277 @property 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

278 def model_extra(self) -> dict[str, Any] | None: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

279 """Get extra fields set during validation. 

280 

281 Returns: 

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

283 """ 

284 return self.__pydantic_extra__ 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

285 

286 @property 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

287 def model_fields_set(self) -> set[str]: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

289 

290 Returns: 

291 A set of strings representing the fields that have been set, 

292 i.e. that were not filled from defaults. 

293 """ 

294 return self.__pydantic_fields_set__ 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

295 

296 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

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

299 

300 Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. 

301 Default values are respected, but no other validation is performed. 

302 

303 !!! note 

304 `model_construct()` generally respects the `model_config.extra` setting on the provided model. 

305 That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__` 

306 and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored. 

307 Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in 

308 an error if extra values are passed, but they will be ignored. 

309 

310 Args: 

311 _fields_set: A set of field names that were originally explicitly set during instantiation. If provided, 

312 this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute. 

313 Otherwise, the field names from the `values` argument will be used. 

314 values: Trusted or pre-validated data dictionary. 

315 

316 Returns: 

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

318 """ 

319 m = cls.__new__(cls) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

320 fields_values: dict[str, Any] = {} 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

321 fields_set = set() 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

322 

323 for name, field in cls.__pydantic_fields__.items(): 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

324 if field.alias is not None and field.alias in values: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

325 fields_values[name] = values.pop(field.alias) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

326 fields_set.add(name) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

327 

328 if (name not in fields_set) and (field.validation_alias is not None): 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

329 validation_aliases: list[str | AliasPath] = ( 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

330 field.validation_alias.choices 

331 if isinstance(field.validation_alias, AliasChoices) 

332 else [field.validation_alias] 

333 ) 

334 

335 for alias in validation_aliases: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

336 if isinstance(alias, str) and alias in values: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

337 fields_values[name] = values.pop(alias) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

338 fields_set.add(name) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

339 break 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

340 elif isinstance(alias, AliasPath): 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

341 value = alias.search_dict_for_path(values) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

342 if value is not PydanticUndefined: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

343 fields_values[name] = value 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

344 fields_set.add(name) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

345 break 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

346 

347 if name not in fields_set: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

348 if name in values: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

349 fields_values[name] = values.pop(name) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

350 fields_set.add(name) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

351 elif not field.is_required(): 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

352 fields_values[name] = field.get_default(call_default_factory=True, validated_data=fields_values) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

353 if _fields_set is None: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

354 _fields_set = fields_set 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

355 

356 _extra: dict[str, Any] | None = values if cls.model_config.get('extra') == 'allow' else None 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

357 _object_setattr(m, '__dict__', fields_values) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

358 _object_setattr(m, '__pydantic_fields_set__', _fields_set) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

359 if not cls.__pydantic_root_model__: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

360 _object_setattr(m, '__pydantic_extra__', _extra) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

361 

362 if cls.__pydantic_post_init__: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

363 m.model_post_init(None) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

364 # update private attributes with values set 

365 if hasattr(m, '__pydantic_private__') and m.__pydantic_private__ is not None: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

366 for k, v in values.items(): 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

367 if k in m.__private_attributes__: 367 ↛ 366line 367 didn't jump to line 366 because the condition on line 367 was always true32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

368 m.__pydantic_private__[k] = v 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

369 

370 elif not cls.__pydantic_root_model__: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

371 # Note: if there are any private attributes, cls.__pydantic_post_init__ would exist 

372 # Since it doesn't, that means that `__pydantic_private__` should be set to None 

373 _object_setattr(m, '__pydantic_private__', None) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

374 

375 return m 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

376 

377 def model_copy(self, *, update: Mapping[str, Any] | None = None, deep: bool = False) -> Self: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

378 """!!! abstract "Usage Documentation" 

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

380 

381 Returns a copy of the model. 

382 

383 !!! note 

384 The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This 

385 might have unexpected side effects if you store anything in it, on top of the model 

386 fields (e.g. the value of [cached properties][functools.cached_property]). 

387 

388 Args: 

389 update: Values to change/add in the new model. Note: the data is not validated 

390 before creating the new model. You should trust this data. 

391 deep: Set to `True` to make a deep copy of the model. 

392 

393 Returns: 

394 New model instance. 

395 """ 

396 copied = self.__deepcopy__() if deep else self.__copy__() 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

397 if update: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

398 if self.model_config.get('extra') == 'allow': 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

399 for k, v in update.items(): 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

400 if k in self.__pydantic_fields__: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

401 copied.__dict__[k] = v 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

402 else: 

403 if copied.__pydantic_extra__ is None: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

404 copied.__pydantic_extra__ = {} 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

405 copied.__pydantic_extra__[k] = v 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

406 else: 

407 copied.__dict__.update(update) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

408 copied.__pydantic_fields_set__.update(update.keys()) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

409 return copied 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

410 

411 def model_dump( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

412 self, 

413 *, 

414 mode: Literal['json', 'python'] | str = 'python', 

415 include: IncEx | None = None, 

416 exclude: IncEx | None = None, 

417 context: Any | None = None, 

418 by_alias: bool = False, 

419 exclude_unset: bool = False, 

420 exclude_defaults: bool = False, 

421 exclude_none: bool = False, 

422 round_trip: bool = False, 

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

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

425 serialize_as_any: bool = False, 

426 ) -> dict[str, Any]: 

427 """!!! abstract "Usage Documentation" 

428 [`model_dump`](../concepts/serialization.md#modelmodel_dump) 

429 

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

431 

432 Args: 

433 mode: The mode in which `to_python` should run. 

434 If mode is 'json', the output will only contain JSON serializable types. 

435 If mode is 'python', the output may contain non-JSON-serializable Python objects. 

436 include: A set of fields to include in the output. 

437 exclude: A set of fields to exclude from the output. 

438 context: Additional context to pass to the serializer. 

439 by_alias: Whether to use the field's alias in the dictionary key if defined. 

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

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

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

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

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

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

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

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

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

449 

450 Returns: 

451 A dictionary representation of the model. 

452 """ 

453 return self.__pydantic_serializer__.to_python( 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

454 self, 

455 mode=mode, 

456 by_alias=by_alias, 

457 include=include, 

458 exclude=exclude, 

459 context=context, 

460 exclude_unset=exclude_unset, 

461 exclude_defaults=exclude_defaults, 

462 exclude_none=exclude_none, 

463 round_trip=round_trip, 

464 warnings=warnings, 

465 fallback=fallback, 

466 serialize_as_any=serialize_as_any, 

467 ) 

468 

469 def model_dump_json( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

470 self, 

471 *, 

472 indent: int | None = None, 

473 include: IncEx | None = None, 

474 exclude: IncEx | None = None, 

475 context: Any | None = None, 

476 by_alias: bool = False, 

477 exclude_unset: bool = False, 

478 exclude_defaults: bool = False, 

479 exclude_none: bool = False, 

480 round_trip: bool = False, 

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

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

483 serialize_as_any: bool = False, 

484 ) -> str: 

485 """!!! abstract "Usage Documentation" 

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

487 

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

489 

490 Args: 

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

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

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

494 context: Additional context to pass to the serializer. 

495 by_alias: Whether to serialize using field aliases. 

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

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

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

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

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

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

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

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

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

505 

506 Returns: 

507 A JSON string representation of the model. 

508 """ 

509 return self.__pydantic_serializer__.to_json( 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

510 self, 

511 indent=indent, 

512 include=include, 

513 exclude=exclude, 

514 context=context, 

515 by_alias=by_alias, 

516 exclude_unset=exclude_unset, 

517 exclude_defaults=exclude_defaults, 

518 exclude_none=exclude_none, 

519 round_trip=round_trip, 

520 warnings=warnings, 

521 fallback=fallback, 

522 serialize_as_any=serialize_as_any, 

523 ).decode() 

524 

525 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

526 def model_json_schema( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

527 cls, 

528 by_alias: bool = True, 

529 ref_template: str = DEFAULT_REF_TEMPLATE, 

530 schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema, 

531 mode: JsonSchemaMode = 'validation', 

532 ) -> dict[str, Any]: 

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

534 

535 Args: 

536 by_alias: Whether to use attribute aliases or not. 

537 ref_template: The reference template. 

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

539 `GenerateJsonSchema` with your desired modifications 

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

541 

542 Returns: 

543 The JSON schema for the given model class. 

544 """ 

545 return model_json_schema( 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

546 cls, by_alias=by_alias, ref_template=ref_template, schema_generator=schema_generator, mode=mode 

547 ) 

548 

549 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

550 def model_parametrized_name(cls, params: tuple[type[Any], ...]) -> str: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

552 

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

554 

555 Args: 

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

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

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

559 

560 Returns: 

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

562 

563 Raises: 

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

565 """ 

566 if not issubclass(cls, typing.Generic): 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

567 raise TypeError('Concrete names should only be generated for generic models.') 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

568 

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

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

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

572 param_names = [param if isinstance(param, str) else _repr.display_as_type(param) for param in params] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

573 params_component = ', '.join(param_names) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

574 return f'{cls.__name__}[{params_component}]' 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

575 

576 def model_post_init(self, context: Any, /) -> None: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

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

579 """ 

580 pass 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

581 

582 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

583 def model_rebuild( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

584 cls, 

585 *, 

586 force: bool = False, 

587 raise_errors: bool = True, 

588 _parent_namespace_depth: int = 2, 

589 _types_namespace: MappingNamespace | None = None, 

590 ) -> bool | None: 

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

592 

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

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

595 

596 Args: 

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

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

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

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

601 

602 Returns: 

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

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

605 """ 

606 if not force and cls.__pydantic_complete__: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

607 return None 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

608 

609 for attr in ('__pydantic_core_schema__', '__pydantic_validator__', '__pydantic_serializer__'): 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

610 if attr in cls.__dict__: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

612 # pydantic-core. Same applies for the core schema that can be reused in schema generation. 

613 delattr(cls, attr) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

614 

615 cls.__pydantic_complete__ = False 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

616 

617 if _types_namespace is not None: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

618 rebuild_ns = _types_namespace 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

619 elif _parent_namespace_depth > 0: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

620 rebuild_ns = _typing_extra.parent_frame_namespace(parent_depth=_parent_namespace_depth, force=True) or {} 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

621 else: 

622 rebuild_ns = {} 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

623 

624 parent_ns = _model_construction.unpack_lenient_weakvaluedict(cls.__pydantic_parent_namespace__) or {} 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

625 

626 ns_resolver = _namespace_utils.NsResolver( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

628 ) 

629 

630 if not cls.__pydantic_fields_complete__: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

631 typevars_map = _generics.get_model_typevars_map(cls) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

632 try: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

633 cls.__pydantic_fields__ = _fields.rebuild_model_fields( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

634 cls, 

635 ns_resolver=ns_resolver, 

636 typevars_map=typevars_map, 

637 ) 

638 except NameError as e: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

639 exc = PydanticUndefinedAnnotation.from_name_error(e) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

640 _mock_val_ser.set_model_mocks(cls, f'`{exc.name}`') 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

641 if raise_errors: 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

642 raise exc from e 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

643 

644 if not raise_errors and not cls.__pydantic_fields_complete__: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

646 return False 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

647 

648 assert cls.__pydantic_fields_complete__ 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

649 

650 return _model_construction.complete_model_class( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

651 cls, 

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

653 raise_errors=raise_errors, 

654 ns_resolver=ns_resolver, 

655 ) 

656 

657 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

658 def model_validate( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

659 cls, 

660 obj: Any, 

661 *, 

662 strict: bool | None = None, 

663 from_attributes: bool | None = None, 

664 context: Any | None = None, 

665 ) -> Self: 

666 """Validate a pydantic model instance. 

667 

668 Args: 

669 obj: The object to validate. 

670 strict: Whether to enforce types strictly. 

671 from_attributes: Whether to extract data from object attributes. 

672 context: Additional context to pass to the validator. 

673 

674 Raises: 

675 ValidationError: If the object could not be validated. 

676 

677 Returns: 

678 The validated model instance. 

679 """ 

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

681 __tracebackhide__ = True 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

682 return cls.__pydantic_validator__.validate_python( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

683 obj, strict=strict, from_attributes=from_attributes, context=context 

684 ) 

685 

686 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

687 def model_validate_json( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

688 cls, 

689 json_data: str | bytes | bytearray, 

690 *, 

691 strict: bool | None = None, 

692 context: Any | None = None, 

693 ) -> Self: 

694 """!!! abstract "Usage Documentation" 

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

696 

697 Validate the given JSON data against the Pydantic model. 

698 

699 Args: 

700 json_data: The JSON data to validate. 

701 strict: Whether to enforce types strictly. 

702 context: Extra variables to pass to the validator. 

703 

704 Returns: 

705 The validated Pydantic model. 

706 

707 Raises: 

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

709 """ 

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

711 __tracebackhide__ = True 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

712 return cls.__pydantic_validator__.validate_json(json_data, strict=strict, context=context) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

713 

714 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

715 def model_validate_strings( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

716 cls, 

717 obj: Any, 

718 *, 

719 strict: bool | None = None, 

720 context: Any | None = None, 

721 ) -> Self: 

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

723 

724 Args: 

725 obj: The object containing string data to validate. 

726 strict: Whether to enforce types strictly. 

727 context: Extra variables to pass to the validator. 

728 

729 Returns: 

730 The validated Pydantic model. 

731 """ 

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

733 __tracebackhide__ = True 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

734 return cls.__pydantic_validator__.validate_strings(obj, strict=strict, context=context) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

735 

736 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

737 def __get_pydantic_core_schema__(cls, source: type[BaseModel], handler: GetCoreSchemaHandler, /) -> CoreSchema: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

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

740 # *not* be called if not overridden. 

741 warnings.warn( 

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

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

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

745 'side effects.', 

746 PydanticDeprecatedSince211, 

747 stacklevel=2, 

748 ) 

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

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

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

752 return cls.__pydantic_core_schema__ 

753 

754 return handler(source) 

755 

756 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

757 def __get_pydantic_json_schema__( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

758 cls, 

759 core_schema: CoreSchema, 

760 handler: GetJsonSchemaHandler, 

761 /, 

762 ) -> JsonSchemaValue: 

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

764 

765 Args: 

766 core_schema: A `pydantic-core` CoreSchema. 

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

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

769 or just call the handler with the original schema. 

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

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

772 generation fails. 

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

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

775 for a type. 

776 

777 Returns: 

778 A JSON schema, as a Python object. 

779 """ 

780 return handler(core_schema) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

781 

782 @classmethod 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

783 def __pydantic_init_subclass__(cls, **kwargs: Any) -> None: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

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

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

786 be present when this is called. 

787 

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

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

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

791 

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

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

794 

795 Args: 

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

797 by pydantic. 

798 """ 

799 pass 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

800 

801 def __class_getitem__( 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

802 cls, typevar_values: type[Any] | tuple[type[Any], ...] 

803 ) -> type[BaseModel] | _forward_ref.PydanticRecursiveRef: 

804 cached = _generics.get_cached_generic_type_early(cls, typevar_values) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

805 if cached is not None: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

806 return cached 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

807 

808 if cls is BaseModel: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

809 raise TypeError('Type parameters should be placed on typing.Generic, not BaseModel') 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

810 if not hasattr(cls, '__parameters__'): 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

811 raise TypeError(f'{cls} cannot be parametrized because it does not inherit from typing.Generic') 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

812 if not cls.__pydantic_generic_metadata__['parameters'] and typing.Generic not in cls.__bases__: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

813 raise TypeError(f'{cls} is not a generic class') 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

814 

815 if not isinstance(typevar_values, tuple): 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

816 typevar_values = (typevar_values,) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

817 

818 # For a model `class Model[T, U, V = int](BaseModel): ...` parametrized with `(str, bool)`, 

819 # this gives us `{T: str, U: bool, V: int}`: 

820 typevars_map = _generics.map_generic_model_arguments(cls, typevar_values) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

821 # We also update the provided args to use defaults values (`(str, bool)` becomes `(str, bool, int)`): 

822 typevar_values = tuple(v for v in typevars_map.values()) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

823 

824 if _utils.all_identical(typevars_map.keys(), typevars_map.values()) and typevars_map: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

825 submodel = cls # if arguments are equal to parameters it's the same object 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

826 _generics.set_cached_generic_type(cls, typevar_values, submodel) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

827 else: 

828 parent_args = cls.__pydantic_generic_metadata__['args'] 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

829 if not parent_args: 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

830 args = typevar_values 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

831 else: 

832 args = tuple(_generics.replace_types(arg, typevars_map) for arg in parent_args) 32 ctx1zAmrnsciadCoDEtuvwjkefBFpxqyglbh

833 

834 origin = cls.__pydantic_generic_metadata__['origin'] or cls 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh

835 model_name = origin.model_parametrized_name(args) 39 ctx1zAmrnsciadCoDEtuvwjkefMKLGHIJBFpxqyglbh