Coverage for pydantic/main.py: 98.10%

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

8 

9import operator 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

10import sys 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

11import types 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

12import typing 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

13import warnings 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

14from collections.abc import Generator, Mapping 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

15from copy import copy, deepcopy 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

16from functools import cached_property 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

17from typing import ( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

31import typing_extensions 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

32from pydantic_core import PydanticUndefined, ValidationError 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

33from typing_extensions import Self, TypeAlias, Unpack 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

34 

35from . import PydanticDeprecatedSince20, PydanticDeprecatedSince211 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

36from ._internal import ( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

50from .aliases import AliasChoices, AliasPath 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

51from .annotated_handlers import GetCoreSchemaHandler, GetJsonSchemaHandler 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

52from .config import ConfigDict 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

53from .errors import PydanticUndefinedAnnotation, PydanticUserError 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

55from .plugin._schema_validator import PluggableSchemaValidator 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

56 

57if TYPE_CHECKING: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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 ctx1x

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

71 

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

73 

74# Keep these type aliases available at runtime: 

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

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

80 

81_object_setattr = _model_construction.object_setattr 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

82 

83 

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

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

86 error_type = 'frozen_instance' 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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

88 error_type = 'frozen_field' 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

89 else: 

90 return 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

91 

92 raise ValidationError.from_exception_data( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

98 model.__dict__[name] = val 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

99 model.__pydantic_fields_set__.add(name) 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

100 

101 

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

103 if getattr(model, '__pydantic_private__', None) is None: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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__', {}) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

109 model.__pydantic_private__[name] = val # pyright: ignore[reportOptionalSubscript] 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

110 

111 

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

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

157 """ 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

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

159 """ 

160 

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

162 """The names of the class variables defined on the model.""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

163 

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

165 """Metadata about the private attributes of the model.""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

166 

167 __signature__: ClassVar[Signature] 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

168 """The synthesized `__init__` [`Signature`][inspect.Signature] of the model.""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

169 

170 __pydantic_complete__: ClassVar[bool] = False 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

172 

173 __pydantic_core_schema__: ClassVar[CoreSchema] 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

174 """The core schema of the model.""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

175 

176 __pydantic_custom_init__: ClassVar[bool] 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

177 """Whether the model has a custom `__init__` method.""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

181 """Metadata containing the decorators defined on the model. 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

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

183 

184 __pydantic_generic_metadata__: ClassVar[_generics.PydanticGenericMetadata] 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

185 """Metadata for generic models; contains data used for a similar purpose to 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

189 """Parent namespace of the model, used for automatic rebuilding of models.""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

190 

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

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

193 

194 __pydantic_root_model__: ClassVar[bool] = False 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

195 """Whether the model is a [`RootModel`][pydantic.root_model.RootModel].""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

196 

197 __pydantic_serializer__: ClassVar[SchemaSerializer] 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

199 

200 __pydantic_validator__: ClassVar[SchemaValidator | PluggableSchemaValidator] 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

202 

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

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

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

209 """`__setattr__` handlers. Memoizing the handlers leads to a dramatic performance improvement in `__setattr__`""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

210 

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

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

213 

214 __pydantic_extra__: Dict[str, Any] | None = _model_construction.NoInitField(init=False) # noqa: UP006 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

216 

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

218 """The names of fields explicitly set during instantiation.""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

219 

220 __pydantic_private__: Dict[str, Any] | None = _model_construction.NoInitField(init=False) # noqa: UP006 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

221 """Values of private attributes set on the model instance.""" 35 ctx1vAwBciadmopxCDEFjkefqrsPyGzHglbhntu

222 

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

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

242 

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

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

254 if self is not validated_self: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

255 warnings.warn( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

264 

265 @_utils.deprecated_instance_property 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

266 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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__', {}) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

275 

276 @_utils.deprecated_instance_property 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

277 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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__', {}) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

286 

287 @property 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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__ 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

295 

296 @property 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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__ 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

305 

306 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

330 fields_values: dict[str, Any] = {} 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

331 fields_set = set() 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

332 

333 for name, field in cls.__pydantic_fields__.items(): 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

334 if field.alias is not None and field.alias in values: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

335 fields_values[name] = values.pop(field.alias) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

336 fields_set.add(name) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

337 

338 if (name not in fields_set) and (field.validation_alias is not None): 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

339 validation_aliases: list[str | AliasPath] = ( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

346 if isinstance(alias, str) and alias in values: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

347 fields_values[name] = values.pop(alias) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

348 fields_set.add(name) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

349 break 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

350 elif isinstance(alias, AliasPath): 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

351 value = alias.search_dict_for_path(values) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

352 if value is not PydanticUndefined: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

353 fields_values[name] = value 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

354 fields_set.add(name) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

355 break 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

356 

357 if name not in fields_set: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

358 if name in values: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

359 fields_values[name] = values.pop(name) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

360 fields_set.add(name) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

361 elif not field.is_required(): 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

362 fields_values[name] = field.get_default(call_default_factory=True, validated_data=fields_values) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

363 if _fields_set is None: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

364 _fields_set = fields_set 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

365 

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

367 _object_setattr(m, '__dict__', fields_values) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

368 _object_setattr(m, '__pydantic_fields_set__', _fields_set) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

369 if not cls.__pydantic_root_model__: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

370 _object_setattr(m, '__pydantic_extra__', _extra) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

371 

372 if cls.__pydantic_post_init__: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

373 m.model_post_init(None) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

374 # update private attributes with values set 

375 if hasattr(m, '__pydantic_private__') and m.__pydantic_private__ is not None: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

376 for k, v in values.items(): 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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

378 m.__pydantic_private__[k] = v 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

379 

380 elif not cls.__pydantic_root_model__: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

384 

385 return m 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

386 

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

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

389 [`model_copy`](../concepts/models.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__() 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

407 if update: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

408 if self.model_config.get('extra') == 'allow': 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

409 for k, v in update.items(): 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

410 if k in self.__pydantic_fields__: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

411 copied.__dict__[k] = v 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

412 else: 

413 if copied.__pydantic_extra__ is None: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

414 copied.__pydantic_extra__ = {} 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

415 copied.__pydantic_extra__[k] = v 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

416 else: 

417 copied.__dict__.update(update) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

418 copied.__pydantic_fields_set__.update(update.keys()) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

419 return copied 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

420 

421 def model_dump( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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#python-mode) 

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( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

480 self, 

481 *, 

482 indent: int | None = None, 

483 ensure_ascii: bool = False, 

484 include: IncEx | None = None, 

485 exclude: IncEx | None = None, 

486 context: Any | None = None, 

487 by_alias: bool | None = None, 

488 exclude_unset: bool = False, 

489 exclude_defaults: bool = False, 

490 exclude_none: bool = False, 

491 round_trip: bool = False, 

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

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

494 serialize_as_any: bool = False, 

495 ) -> str: 

496 """!!! abstract "Usage Documentation" 

497 [`model_dump_json`](../concepts/serialization.md#json-mode) 

498 

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

500 

501 Args: 

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

503 ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped. 

504 If `False` (the default), these characters will be output as-is. 

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

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

507 context: Additional context to pass to the serializer. 

508 by_alias: Whether to serialize using field aliases. 

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

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

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

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

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

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

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

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

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

518 

519 Returns: 

520 A JSON string representation of the model. 

521 """ 

522 return self.__pydantic_serializer__.to_json( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

523 self, 

524 indent=indent, 

525 ensure_ascii=ensure_ascii, 

526 include=include, 

527 exclude=exclude, 

528 context=context, 

529 by_alias=by_alias, 

530 exclude_unset=exclude_unset, 

531 exclude_defaults=exclude_defaults, 

532 exclude_none=exclude_none, 

533 round_trip=round_trip, 

534 warnings=warnings, 

535 fallback=fallback, 

536 serialize_as_any=serialize_as_any, 

537 ).decode() 

538 

539 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

540 def model_json_schema( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

541 cls, 

542 by_alias: bool = True, 

543 ref_template: str = DEFAULT_REF_TEMPLATE, 

544 schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema, 

545 mode: JsonSchemaMode = 'validation', 

546 ) -> dict[str, Any]: 

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

548 

549 Args: 

550 by_alias: Whether to use attribute aliases or not. 

551 ref_template: The reference template. 

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

553 `GenerateJsonSchema` with your desired modifications 

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

555 

556 Returns: 

557 The JSON schema for the given model class. 

558 """ 

559 return model_json_schema( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

560 cls, by_alias=by_alias, ref_template=ref_template, schema_generator=schema_generator, mode=mode 

561 ) 

562 

563 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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

566 

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

568 

569 Args: 

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

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

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

573 

574 Returns: 

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

576 

577 Raises: 

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

579 """ 

580 if not issubclass(cls, typing.Generic): 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

581 raise TypeError('Concrete names should only be generated for generic models.') 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

582 

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

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

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

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

587 params_component = ', '.join(param_names) 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

588 return f'{cls.__name__}[{params_component}]' 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

589 

590 def model_post_init(self, context: Any, /) -> None: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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

593 """ 

594 

595 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

596 def model_rebuild( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

597 cls, 

598 *, 

599 force: bool = False, 

600 raise_errors: bool = True, 

601 _parent_namespace_depth: int = 2, 

602 _types_namespace: MappingNamespace | None = None, 

603 ) -> bool | None: 

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

605 

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

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

608 

609 Args: 

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

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

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

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

614 

615 Returns: 

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

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

618 """ 

619 already_complete = cls.__pydantic_complete__ 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

620 if already_complete and not force: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

621 return None 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

622 

623 cls.__pydantic_complete__ = False 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

624 

625 for attr in ('__pydantic_core_schema__', '__pydantic_validator__', '__pydantic_serializer__'): 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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

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

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

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

631 delattr(cls, attr) 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

632 

633 if _types_namespace is not None: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

634 rebuild_ns = _types_namespace 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

635 elif _parent_namespace_depth > 0: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

637 else: 

638 rebuild_ns = {} 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

639 

640 parent_ns = _model_construction.unpack_lenient_weakvaluedict(cls.__pydantic_parent_namespace__) or {} 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

641 

642 ns_resolver = _namespace_utils.NsResolver( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

644 ) 

645 

646 return _model_construction.complete_model_class( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

647 cls, 

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

649 ns_resolver, 

650 raise_errors=raise_errors, 

651 # If the model was already complete, we don't need to call the hook again. 

652 call_on_complete_hook=not already_complete, 

653 ) 

654 

655 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

656 def model_validate( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

657 cls, 

658 obj: Any, 

659 *, 

660 strict: bool | None = None, 

661 from_attributes: bool | None = None, 

662 context: Any | None = None, 

663 by_alias: bool | None = None, 

664 by_name: bool | 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 by_alias: Whether to use the field's alias when validating against the provided input data. 

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

675 

676 Raises: 

677 ValidationError: If the object could not be validated. 

678 

679 Returns: 

680 The validated model instance. 

681 """ 

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

683 __tracebackhide__ = True 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

684 

685 if by_alias is False and by_name is not True: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

686 raise PydanticUserError( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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

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

689 ) 

690 

691 return cls.__pydantic_validator__.validate_python( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

693 ) 

694 

695 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

696 def model_validate_json( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

697 cls, 

698 json_data: str | bytes | bytearray, 

699 *, 

700 strict: bool | None = None, 

701 context: Any | None = None, 

702 by_alias: bool | None = None, 

703 by_name: bool | None = None, 

704 ) -> Self: 

705 """!!! abstract "Usage Documentation" 

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

707 

708 Validate the given JSON data against the Pydantic model. 

709 

710 Args: 

711 json_data: The JSON data to validate. 

712 strict: Whether to enforce types strictly. 

713 context: Extra variables to pass to the validator. 

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

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

716 

717 Returns: 

718 The validated Pydantic model. 

719 

720 Raises: 

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

722 """ 

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

724 __tracebackhide__ = True 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

725 

726 if by_alias is False and by_name is not True: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

727 raise PydanticUserError( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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

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

730 ) 

731 

732 return cls.__pydantic_validator__.validate_json( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

733 json_data, strict=strict, context=context, by_alias=by_alias, by_name=by_name 

734 ) 

735 

736 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

737 def model_validate_strings( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

738 cls, 

739 obj: Any, 

740 *, 

741 strict: bool | None = None, 

742 context: Any | None = None, 

743 by_alias: bool | None = None, 

744 by_name: bool | None = None, 

745 ) -> Self: 

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

747 

748 Args: 

749 obj: The object containing string data to validate. 

750 strict: Whether to enforce types strictly. 

751 context: Extra variables to pass to the validator. 

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

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

754 

755 Returns: 

756 The validated Pydantic model. 

757 """ 

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

759 __tracebackhide__ = True 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

760 

761 if by_alias is False and by_name is not True: 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

762 raise PydanticUserError( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

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

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

765 ) 

766 

767 return cls.__pydantic_validator__.validate_strings( 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

768 obj, strict=strict, context=context, by_alias=by_alias, by_name=by_name 

769 ) 

770 

771 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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

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

775 # *not* be called if not overridden. 

776 warnings.warn( 

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

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

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

780 'side effects.', 

781 PydanticDeprecatedSince211, 

782 stacklevel=2, 

783 ) 

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

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

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

787 return cls.__pydantic_core_schema__ 

788 

789 return handler(source) 

790 

791 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

792 def __get_pydantic_json_schema__( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

793 cls, 

794 core_schema: CoreSchema, 

795 handler: GetJsonSchemaHandler, 

796 /, 

797 ) -> JsonSchemaValue: 

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

799 

800 Args: 

801 core_schema: A `pydantic-core` CoreSchema. 

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

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

804 or just call the handler with the original schema. 

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

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

807 generation fails. 

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

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

810 for a type. 

811 

812 Returns: 

813 A JSON schema, as a Python object. 

814 """ 

815 return handler(core_schema) 41 ctx1IJvAwBciadmopLxMNCDEFjkefqrsKOyGzHglbhntu

816 

817 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

818 def __pydantic_init_subclass__(cls, **kwargs: Any) -> None: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

820 only after basic class initialization is complete. In particular, attributes like `model_fields` will 

821 be present when this is called, but forward annotations are not guaranteed to be resolved yet, 

822 meaning that creating an instance of the class may fail. 

823 

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

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

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

827 

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

829 any kwargs passed to the class definition that aren't used internally by Pydantic. 

830 

831 Args: 

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

833 by Pydantic. 

834 

835 Note: 

836 You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__] 

837 instead, which is called once the class and its fields are fully initialized and ready for validation. 

838 """ 

839 

840 @classmethod 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

841 def __pydantic_on_complete__(cls) -> None: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

842 """This is called once the class and its fields are fully initialized and ready to be used. 

843 

844 This typically happens when the class is created (just before 

845 [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), 

846 except when forward annotations are used that could not immediately be resolved. 

847 In that case, it will be called later, when the model is rebuilt automatically or explicitly using 

848 [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. 

849 """ 

850 

851 def __class_getitem__( 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

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

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

854 cached = _generics.get_cached_generic_type_early(cls, typevar_values) 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu

855 if cached is not None: 42 ctx1IJvAwBciadmopLxMNCDEFjkefqrsPKOyGzHglbhntu