Coverage for pydantic/main.py: 98.09%

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

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

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

623 delattr(cls, attr) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

624 

625 cls.__pydantic_complete__ = False 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

626 

627 if _types_namespace is not None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

628 rebuild_ns = _types_namespace 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

629 elif _parent_namespace_depth > 0: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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

631 else: 

632 rebuild_ns = {} 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

633 

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

635 

636 ns_resolver = _namespace_utils.NsResolver( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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

638 ) 

639 

640 return _model_construction.complete_model_class( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

641 cls, 

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

643 ns_resolver, 

644 raise_errors=raise_errors, 

645 ) 

646 

647 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

648 def model_validate( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

649 cls, 

650 obj: Any, 

651 *, 

652 strict: bool | None = None, 

653 from_attributes: bool | None = None, 

654 context: Any | None = None, 

655 by_alias: bool | None = None, 

656 by_name: bool | None = None, 

657 ) -> Self: 

658 """Validate a pydantic model instance. 

659 

660 Args: 

661 obj: The object to validate. 

662 strict: Whether to enforce types strictly. 

663 from_attributes: Whether to extract data from object attributes. 

664 context: Additional context to pass to the validator. 

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

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

667 

668 Raises: 

669 ValidationError: If the object could not be validated. 

670 

671 Returns: 

672 The validated model instance. 

673 """ 

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

675 __tracebackhide__ = True 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

676 

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

678 raise PydanticUserError( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

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

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

681 ) 

682 

683 return cls.__pydantic_validator__.validate_python( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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

685 ) 

686 

687 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

688 def model_validate_json( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

689 cls, 

690 json_data: str | bytes | bytearray, 

691 *, 

692 strict: bool | None = None, 

693 context: Any | None = None, 

694 by_alias: bool | None = None, 

695 by_name: bool | None = None, 

696 ) -> Self: 

697 """!!! abstract "Usage Documentation" 

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

699 

700 Validate the given JSON data against the Pydantic model. 

701 

702 Args: 

703 json_data: The JSON data to validate. 

704 strict: Whether to enforce types strictly. 

705 context: Extra variables to pass to the validator. 

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

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

708 

709 Returns: 

710 The validated Pydantic model. 

711 

712 Raises: 

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

714 """ 

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

716 __tracebackhide__ = True 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

717 

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

719 raise PydanticUserError( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

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

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

722 ) 

723 

724 return cls.__pydantic_validator__.validate_json( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

725 json_data, strict=strict, context=context, by_alias=by_alias, by_name=by_name 

726 ) 

727 

728 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

729 def model_validate_strings( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

730 cls, 

731 obj: Any, 

732 *, 

733 strict: bool | None = None, 

734 context: Any | None = None, 

735 by_alias: bool | None = None, 

736 by_name: bool | None = None, 

737 ) -> Self: 

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

739 

740 Args: 

741 obj: The object containing string data to validate. 

742 strict: Whether to enforce types strictly. 

743 context: Extra variables to pass to the validator. 

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

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

746 

747 Returns: 

748 The validated Pydantic model. 

749 """ 

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

751 __tracebackhide__ = True 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

752 

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

754 raise PydanticUserError( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

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

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

757 ) 

758 

759 return cls.__pydantic_validator__.validate_strings( 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

760 obj, strict=strict, context=context, by_alias=by_alias, by_name=by_name 

761 ) 

762 

763 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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

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

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

767 # *not* be called if not overridden. 

768 warnings.warn( 

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

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

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

772 'side effects.', 

773 PydanticDeprecatedSince211, 

774 stacklevel=2, 

775 ) 

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

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

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

779 return cls.__pydantic_core_schema__ 

780 

781 return handler(source) 

782 

783 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

784 def __get_pydantic_json_schema__( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

785 cls, 

786 core_schema: CoreSchema, 

787 handler: GetJsonSchemaHandler, 

788 /, 

789 ) -> JsonSchemaValue: 

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

791 

792 Args: 

793 core_schema: A `pydantic-core` CoreSchema. 

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

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

796 or just call the handler with the original schema. 

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

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

799 generation fails. 

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

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

802 for a type. 

803 

804 Returns: 

805 A JSON schema, as a Python object. 

806 """ 

807 return handler(core_schema) 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

808 

809 @classmethod 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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

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

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

813 be present when this is called. 

814 

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

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

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

818 

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

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

821 

822 Args: 

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

824 by pydantic. 

825 """ 

826 pass 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

827 

828 def __class_getitem__( 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

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

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

831 cached = _generics.get_cached_generic_type_early(cls, typevar_values) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

832 if cached is not None: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

833 return cached 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

834 

835 if cls is BaseModel: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

836 raise TypeError('Type parameters should be placed on typing.Generic, not BaseModel') 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

837 if not hasattr(cls, '__parameters__'): 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

838 raise TypeError(f'{cls} cannot be parametrized because it does not inherit from typing.Generic') 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

839 if not cls.__pydantic_generic_metadata__['parameters'] and typing.Generic not in cls.__bases__: 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

840 raise TypeError(f'{cls} is not a generic class') 35 ctx1CDpuqvcladeFrGHwxyzmnfghEIsAtBiobjk

841 

842 if not isinstance(typevar_values, tuple): 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

843 typevar_values = (typevar_values,) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk

844 

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

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

847 typevars_map = _generics.map_generic_model_arguments(cls, typevar_values) 42 ctx1CDpuqvcladeFrGHwxyzmnfghPNOJKLMEIsAtBiobjk