Coverage for pydantic/main.py: 98.82%

487 statements  

« prev     ^ index     » next       coverage.py v7.5.4, created at 2024-07-03 19:29 +0000

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

2 

3from __future__ import annotations as _annotations 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

4 

5import operator 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

6import sys 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

7import types 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

8import typing 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

9import warnings 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

10from copy import copy, deepcopy 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

11from typing import ( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

12 TYPE_CHECKING, 

13 Any, 

14 Callable, 

15 ClassVar, 

16 Dict, 

17 Generator, 

18 Literal, 

19 Set, 

20 Tuple, 

21 TypeVar, 

22 Union, 

23 cast, 

24 overload, 

25) 

26 

27import pydantic_core 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

28import typing_extensions 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

29from pydantic_core import PydanticUndefined 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

30from typing_extensions import Self, TypeAlias, Unpack 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

31 

32from ._internal import ( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

33 _config, 

34 _decorators, 

35 _fields, 

36 _forward_ref, 

37 _generics, 

38 _mock_val_ser, 

39 _model_construction, 

40 _repr, 

41 _typing_extra, 

42 _utils, 

43) 

44from ._migration import getattr_migration 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

45from .aliases import AliasChoices, AliasPath 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

46from .annotated_handlers import GetCoreSchemaHandler, GetJsonSchemaHandler 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

47from .config import ConfigDict 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

48from .errors import PydanticUndefinedAnnotation, PydanticUserError 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

49from .json_schema import DEFAULT_REF_TEMPLATE, GenerateJsonSchema, JsonSchemaMode, JsonSchemaValue, model_json_schema 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

50from .warnings import PydanticDeprecatedSince20 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

51 

52# Always define certain types that are needed to resolve method type hints/annotations 

53# (even when not type checking) via typing.get_type_hints. 

54ModelT = TypeVar('ModelT', bound='BaseModel') 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

55TupleGenerator = Generator[Tuple[str, Any], None, None] 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

56# should be `set[int] | set[str] | dict[int, IncEx] | dict[str, IncEx] | None`, but mypy can't cope 

57IncEx: TypeAlias = Union[Set[int], Set[str], Dict[int, Any], Dict[str, Any], None] 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

58 

59 

60if TYPE_CHECKING: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

61 from inspect import Signature 

62 from pathlib import Path 

63 

64 from pydantic_core import CoreSchema, SchemaSerializer, SchemaValidator 

65 

66 from ._internal._utils import AbstractSetIntStr, MappingIntStrAny 

67 from .deprecated.parse import Protocol as DeprecatedParseProtocol 

68 from .fields import ComputedFieldInfo, FieldInfo, ModelPrivateAttr 

69 from .fields import PrivateAttr as _PrivateAttr 1u

70else: 

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

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

73 DeprecationWarning = PydanticDeprecatedSince20 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

74 

75__all__ = 'BaseModel', 'create_model' 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

76 

77_object_setattr = _model_construction.object_setattr 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

78 

79 

80class BaseModel(metaclass=_model_construction.ModelMetaclass): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

81 """Usage docs: https://docs.pydantic.dev/2.8/concepts/models/ 

82 

83 A base class for creating Pydantic models. 

84 

85 Attributes: 

86 __class_vars__: The names of classvars defined on the model. 

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

88 __signature__: The signature for instantiating the model. 

89 

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

91 __pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer. 

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

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

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

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

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

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

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

99 __pydantic_root_model__: Whether the model is a `RootModel`. 

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

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

102 

103 __pydantic_extra__: An instance attribute with the values of extra fields from validation when 

104 `model_config['extra'] == 'allow'`. 

105 __pydantic_fields_set__: An instance attribute with the names of fields explicitly set. 

106 __pydantic_private__: Instance attribute with the values of private attributes set on the model instance. 

107 """ 

108 

109 if TYPE_CHECKING: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

110 # Here we provide annotations for the attributes of BaseModel. 

111 # Many of these are populated by the metaclass, which is why this section is in a `TYPE_CHECKING` block. 

112 # However, for the sake of easy review, we have included type annotations of all class and instance attributes 

113 # of `BaseModel` here: 

114 

115 # Class attributes 

116 model_config: ClassVar[ConfigDict] 

117 """ 

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

119 """ 

120 

121 model_fields: ClassVar[dict[str, FieldInfo]] 

122 """ 

123 Metadata about the fields defined on the model, 

124 mapping of field names to [`FieldInfo`][pydantic.fields.FieldInfo]. 

125 

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

127 """ 

128 

129 model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] 

130 """A dictionary of computed field names and their corresponding `ComputedFieldInfo` objects.""" 

131 

132 __class_vars__: ClassVar[set[str]] 

133 __private_attributes__: ClassVar[dict[str, ModelPrivateAttr]] 

134 __signature__: ClassVar[Signature] 

135 

136 __pydantic_complete__: ClassVar[bool] 

137 __pydantic_core_schema__: ClassVar[CoreSchema] 

138 __pydantic_custom_init__: ClassVar[bool] 

139 __pydantic_decorators__: ClassVar[_decorators.DecoratorInfos] 

140 __pydantic_generic_metadata__: ClassVar[_generics.PydanticGenericMetadata] 

141 __pydantic_parent_namespace__: ClassVar[dict[str, Any] | None] 

142 __pydantic_post_init__: ClassVar[None | Literal['model_post_init']] 

143 __pydantic_root_model__: ClassVar[bool] 

144 __pydantic_serializer__: ClassVar[SchemaSerializer] 

145 __pydantic_validator__: ClassVar[SchemaValidator] 

146 

147 # Instance attributes 

148 __pydantic_extra__: dict[str, Any] | None = _PrivateAttr() 

149 __pydantic_fields_set__: set[str] = _PrivateAttr() 

150 __pydantic_private__: dict[str, Any] | None = _PrivateAttr() 

151 

152 else: 

153 # `model_fields` and `__pydantic_decorators__` must be set for 

154 # pydantic._internal._generate_schema.GenerateSchema.model_schema to work for a plain BaseModel annotation 

155 model_fields = {} 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

156 model_computed_fields = {} 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

157 

158 __pydantic_decorators__ = _decorators.DecoratorInfos() 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

159 __pydantic_parent_namespace__ = None 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

160 # Prevent `BaseModel` from being instantiated directly: 

161 __pydantic_core_schema__ = _mock_val_ser.MockCoreSchema( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

163 code='base-model-instantiated', 

164 ) 

165 __pydantic_validator__ = _mock_val_ser.MockValSer( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

167 val_or_ser='validator', 

168 code='base-model-instantiated', 

169 ) 

170 __pydantic_serializer__ = _mock_val_ser.MockValSer( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

172 val_or_ser='serializer', 

173 code='base-model-instantiated', 

174 ) 

175 

176 __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__' 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

177 

178 model_config = ConfigDict() 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

179 __pydantic_complete__ = False 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

180 __pydantic_root_model__ = False 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

181 

182 def __init__(self, /, **data: Any) -> None: # type: ignore 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

184 

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

186 validated to form a valid model. 

187 

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

189 """ 

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

191 __tracebackhide__ = True 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

192 self.__pydantic_validator__.validate_python(data, self_instance=self) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

193 

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

195 __init__.__pydantic_base_init__ = True # pyright: ignore[reportFunctionMemberAccess] 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

196 

197 @property 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

198 def model_extra(self) -> dict[str, Any] | None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

199 """Get extra fields set during validation. 

200 

201 Returns: 

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

203 """ 

204 return self.__pydantic_extra__ 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

205 

206 @property 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

207 def model_fields_set(self) -> set[str]: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

209 

210 Returns: 

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

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

213 """ 

214 return self.__pydantic_fields_set__ 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

215 

216 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

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

219 

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

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

222 

223 !!! note 

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

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

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

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

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

229 

230 Args: 

231 _fields_set: The set of field names accepted for the Model instance. 

232 values: Trusted or pre-validated data dictionary. 

233 

234 Returns: 

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

236 """ 

237 m = cls.__new__(cls) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

238 fields_values: dict[str, Any] = {} 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

239 fields_set = set() 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

240 

241 for name, field in cls.model_fields.items(): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

242 if field.alias is not None and field.alias in values: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

243 fields_values[name] = values.pop(field.alias) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

244 fields_set.add(name) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

245 

246 if (name not in fields_set) and (field.validation_alias is not None): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

247 validation_aliases: list[str | AliasPath] = ( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

248 field.validation_alias.choices 

249 if isinstance(field.validation_alias, AliasChoices) 

250 else [field.validation_alias] 

251 ) 

252 

253 for alias in validation_aliases: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

254 if isinstance(alias, str) and alias in values: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

255 fields_values[name] = values.pop(alias) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

256 fields_set.add(name) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

257 break 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

258 elif isinstance(alias, AliasPath): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

259 value = alias.search_dict_for_path(values) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

260 if value is not PydanticUndefined: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

261 fields_values[name] = value 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

262 fields_set.add(name) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

263 break 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

264 

265 if name not in fields_set: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

266 if name in values: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

267 fields_values[name] = values.pop(name) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

268 fields_set.add(name) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

269 elif not field.is_required(): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

270 fields_values[name] = field.get_default(call_default_factory=True) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

271 if _fields_set is None: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

272 _fields_set = fields_set 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

273 

274 _extra: dict[str, Any] | None = ( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

275 {k: v for k, v in values.items()} if cls.model_config.get('extra') == 'allow' else None 

276 ) 

277 _object_setattr(m, '__dict__', fields_values) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

278 _object_setattr(m, '__pydantic_fields_set__', _fields_set) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

279 if not cls.__pydantic_root_model__: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

280 _object_setattr(m, '__pydantic_extra__', _extra) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

281 

282 if cls.__pydantic_post_init__: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

283 m.model_post_init(None) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

284 # update private attributes with values set 

285 if hasattr(m, '__pydantic_private__') and m.__pydantic_private__ is not None: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

286 for k, v in values.items(): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

287 if k in m.__private_attributes__: 287 ↛ 286line 287 didn't jump to line 286 because the condition on line 287 was always true1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

288 m.__pydantic_private__[k] = v 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

289 

290 elif not cls.__pydantic_root_model__: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

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

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

293 _object_setattr(m, '__pydantic_private__', None) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

294 

295 return m 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

296 

297 def model_copy(self, *, update: dict[str, Any] | None = None, deep: bool = False) -> Self: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

298 """Usage docs: https://docs.pydantic.dev/2.8/concepts/serialization/#model_copy 

299 

300 Returns a copy of the model. 

301 

302 Args: 

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

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

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

306 

307 Returns: 

308 New model instance. 

309 """ 

310 copied = self.__deepcopy__() if deep else self.__copy__() 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

311 if update: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

312 if self.model_config.get('extra') == 'allow': 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

313 for k, v in update.items(): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

314 if k in self.model_fields: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

315 copied.__dict__[k] = v 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

316 else: 

317 if copied.__pydantic_extra__ is None: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

318 copied.__pydantic_extra__ = {} 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

319 copied.__pydantic_extra__[k] = v 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

320 else: 

321 copied.__dict__.update(update) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

322 copied.__pydantic_fields_set__.update(update.keys()) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

323 return copied 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

324 

325 def model_dump( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

326 self, 

327 *, 

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

329 include: IncEx = None, 

330 exclude: IncEx = None, 

331 context: Any | None = None, 

332 by_alias: bool = False, 

333 exclude_unset: bool = False, 

334 exclude_defaults: bool = False, 

335 exclude_none: bool = False, 

336 round_trip: bool = False, 

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

338 serialize_as_any: bool = False, 

339 ) -> dict[str, Any]: 

340 """Usage docs: https://docs.pydantic.dev/2.8/concepts/serialization/#modelmodel_dump 

341 

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

343 

344 Args: 

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

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

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

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

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

350 context: Additional context to pass to the serializer. 

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

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

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

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

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

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

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

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

359 

360 Returns: 

361 A dictionary representation of the model. 

362 """ 

363 return self.__pydantic_serializer__.to_python( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

364 self, 

365 mode=mode, 

366 by_alias=by_alias, 

367 include=include, 

368 exclude=exclude, 

369 context=context, 

370 exclude_unset=exclude_unset, 

371 exclude_defaults=exclude_defaults, 

372 exclude_none=exclude_none, 

373 round_trip=round_trip, 

374 warnings=warnings, 

375 serialize_as_any=serialize_as_any, 

376 ) 

377 

378 def model_dump_json( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

379 self, 

380 *, 

381 indent: int | None = None, 

382 include: IncEx = None, 

383 exclude: IncEx = None, 

384 context: Any | None = None, 

385 by_alias: bool = False, 

386 exclude_unset: bool = False, 

387 exclude_defaults: bool = False, 

388 exclude_none: bool = False, 

389 round_trip: bool = False, 

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

391 serialize_as_any: bool = False, 

392 ) -> str: 

393 """Usage docs: https://docs.pydantic.dev/2.8/concepts/serialization/#modelmodel_dump_json 

394 

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

396 

397 Args: 

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

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

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

401 context: Additional context to pass to the serializer. 

402 by_alias: Whether to serialize using field aliases. 

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

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

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

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

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

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

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

410 

411 Returns: 

412 A JSON string representation of the model. 

413 """ 

414 return self.__pydantic_serializer__.to_json( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

415 self, 

416 indent=indent, 

417 include=include, 

418 exclude=exclude, 

419 context=context, 

420 by_alias=by_alias, 

421 exclude_unset=exclude_unset, 

422 exclude_defaults=exclude_defaults, 

423 exclude_none=exclude_none, 

424 round_trip=round_trip, 

425 warnings=warnings, 

426 serialize_as_any=serialize_as_any, 

427 ).decode() 

428 

429 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

430 def model_json_schema( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

431 cls, 

432 by_alias: bool = True, 

433 ref_template: str = DEFAULT_REF_TEMPLATE, 

434 schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema, 

435 mode: JsonSchemaMode = 'validation', 

436 ) -> dict[str, Any]: 

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

438 

439 Args: 

440 by_alias: Whether to use attribute aliases or not. 

441 ref_template: The reference template. 

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

443 `GenerateJsonSchema` with your desired modifications 

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

445 

446 Returns: 

447 The JSON schema for the given model class. 

448 """ 

449 return model_json_schema( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

450 cls, by_alias=by_alias, ref_template=ref_template, schema_generator=schema_generator, mode=mode 

451 ) 

452 

453 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

454 def model_parametrized_name(cls, params: tuple[type[Any], ...]) -> str: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

456 

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

458 

459 Args: 

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

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

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

463 

464 Returns: 

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

466 

467 Raises: 

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

469 """ 

470 if not issubclass(cls, typing.Generic): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

471 raise TypeError('Concrete names should only be generated for generic models.') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

472 

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

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

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

476 param_names = [param if isinstance(param, str) else _repr.display_as_type(param) for param in params] 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

477 params_component = ', '.join(param_names) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

478 return f'{cls.__name__}[{params_component}]' 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

479 

480 def model_post_init(self, __context: Any) -> None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

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

483 """ 

484 pass 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

485 

486 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

487 def model_rebuild( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

488 cls, 

489 *, 

490 force: bool = False, 

491 raise_errors: bool = True, 

492 _parent_namespace_depth: int = 2, 

493 _types_namespace: dict[str, Any] | None = None, 

494 ) -> bool | None: 

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

496 

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

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

499 

500 Args: 

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

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

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

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

505 

506 Returns: 

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

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

509 """ 

510 if not force and cls.__pydantic_complete__: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

511 return None 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

512 else: 

513 if '__pydantic_core_schema__' in cls.__dict__: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

514 delattr(cls, '__pydantic_core_schema__') # delete cached value to ensure full rebuild happens 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

515 if _types_namespace is not None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

516 types_namespace: dict[str, Any] | None = _types_namespace.copy() 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

517 else: 

518 if _parent_namespace_depth > 0: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

519 frame_parent_ns = _typing_extra.parent_frame_namespace(parent_depth=_parent_namespace_depth) or {} 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

520 cls_parent_ns = ( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

521 _model_construction.unpack_lenient_weakvaluedict(cls.__pydantic_parent_namespace__) or {} 

522 ) 

523 types_namespace = {**cls_parent_ns, **frame_parent_ns} 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

524 cls.__pydantic_parent_namespace__ = _model_construction.build_lenient_weakvaluedict(types_namespace) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

525 else: 

526 types_namespace = _model_construction.unpack_lenient_weakvaluedict( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

527 cls.__pydantic_parent_namespace__ 

528 ) 

529 

530 types_namespace = _typing_extra.get_cls_types_namespace(cls, types_namespace) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

531 

532 # manually override defer_build so complete_model_class doesn't skip building the model again 

533 config = {**cls.model_config, 'defer_build': False} 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

534 return _model_construction.complete_model_class( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

535 cls, 

536 cls.__name__, 

537 _config.ConfigWrapper(config, check=False), 

538 raise_errors=raise_errors, 

539 types_namespace=types_namespace, 

540 ) 

541 

542 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

543 def model_validate( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

544 cls, 

545 obj: Any, 

546 *, 

547 strict: bool | None = None, 

548 from_attributes: bool | None = None, 

549 context: Any | None = None, 

550 ) -> Self: 

551 """Validate a pydantic model instance. 

552 

553 Args: 

554 obj: The object to validate. 

555 strict: Whether to enforce types strictly. 

556 from_attributes: Whether to extract data from object attributes. 

557 context: Additional context to pass to the validator. 

558 

559 Raises: 

560 ValidationError: If the object could not be validated. 

561 

562 Returns: 

563 The validated model instance. 

564 """ 

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

566 __tracebackhide__ = True 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

567 return cls.__pydantic_validator__.validate_python( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

568 obj, strict=strict, from_attributes=from_attributes, context=context 

569 ) 

570 

571 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

572 def model_validate_json( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

573 cls, 

574 json_data: str | bytes | bytearray, 

575 *, 

576 strict: bool | None = None, 

577 context: Any | None = None, 

578 ) -> Self: 

579 """Usage docs: https://docs.pydantic.dev/2.8/concepts/json/#json-parsing 

580 

581 Validate the given JSON data against the Pydantic model. 

582 

583 Args: 

584 json_data: The JSON data to validate. 

585 strict: Whether to enforce types strictly. 

586 context: Extra variables to pass to the validator. 

587 

588 Returns: 

589 The validated Pydantic model. 

590 

591 Raises: 

592 ValueError: If `json_data` is not a JSON string. 

593 """ 

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

595 __tracebackhide__ = True 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

596 return cls.__pydantic_validator__.validate_json(json_data, strict=strict, context=context) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

597 

598 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

599 def model_validate_strings( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

600 cls, 

601 obj: Any, 

602 *, 

603 strict: bool | None = None, 

604 context: Any | None = None, 

605 ) -> Self: 

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

607 

608 Args: 

609 obj: The object containing string data to validate. 

610 strict: Whether to enforce types strictly. 

611 context: Extra variables to pass to the validator. 

612 

613 Returns: 

614 The validated Pydantic model. 

615 """ 

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

617 __tracebackhide__ = True 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

618 return cls.__pydantic_validator__.validate_strings(obj, strict=strict, context=context) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

619 

620 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

621 def __get_pydantic_core_schema__(cls, source: type[BaseModel], handler: GetCoreSchemaHandler, /) -> CoreSchema: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

622 """Hook into generating the model's CoreSchema. 

623 

624 Args: 

625 source: The class we are generating a schema for. 

626 This will generally be the same as the `cls` argument if this is a classmethod. 

627 handler: A callable that calls into Pydantic's internal CoreSchema generation logic. 

628 

629 Returns: 

630 A `pydantic-core` `CoreSchema`. 

631 """ 

632 # Only use the cached value from this _exact_ class; we don't want one from a parent class 

633 # This is why we check `cls.__dict__` and don't use `cls.__pydantic_core_schema__` or similar. 

634 schema = cls.__dict__.get('__pydantic_core_schema__') 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

635 if schema is not None and not isinstance(schema, _mock_val_ser.MockCoreSchema): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

636 # Due to the way generic classes are built, it's possible that an invalid schema may be temporarily 

637 # set on generic classes. I think we could resolve this to ensure that we get proper schema caching 

638 # for generics, but for simplicity for now, we just always rebuild if the class has a generic origin. 

639 if not cls.__pydantic_generic_metadata__['origin']: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

640 return cls.__pydantic_core_schema__ 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

641 

642 return handler(source) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

643 

644 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

645 def __get_pydantic_json_schema__( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

646 cls, 

647 core_schema: CoreSchema, 

648 handler: GetJsonSchemaHandler, 

649 /, 

650 ) -> JsonSchemaValue: 

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

652 

653 Args: 

654 core_schema: A `pydantic-core` CoreSchema. 

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

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

657 or just call the handler with the original schema. 

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

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

660 generation fails. 

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

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

663 for a type. 

664 

665 Returns: 

666 A JSON schema, as a Python object. 

667 """ 

668 return handler(core_schema) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

669 

670 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

671 def __pydantic_init_subclass__(cls, **kwargs: Any) -> None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

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

674 be present when this is called. 

675 

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

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

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

679 

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

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

682 

683 Args: 

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

685 by pydantic. 

686 """ 

687 pass 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

688 

689 def __class_getitem__( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

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

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

692 cached = _generics.get_cached_generic_type_early(cls, typevar_values) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

693 if cached is not None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

694 return cached 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

695 

696 if cls is BaseModel: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

697 raise TypeError('Type parameters should be placed on typing.Generic, not BaseModel') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

698 if not hasattr(cls, '__parameters__'): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

699 raise TypeError(f'{cls} cannot be parametrized because it does not inherit from typing.Generic') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

700 if not cls.__pydantic_generic_metadata__['parameters'] and typing.Generic not in cls.__bases__: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

701 raise TypeError(f'{cls} is not a generic class') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

702 

703 if not isinstance(typevar_values, tuple): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

704 typevar_values = (typevar_values,) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

705 _generics.check_parameters_count(cls, typevar_values) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

706 

707 # Build map from generic typevars to passed params 

708 typevars_map: dict[_typing_extra.TypeVarType, type[Any]] = dict( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

709 zip(cls.__pydantic_generic_metadata__['parameters'], typevar_values) 

710 ) 

711 

712 if _utils.all_identical(typevars_map.keys(), typevars_map.values()) and typevars_map: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

713 submodel = cls # if arguments are equal to parameters it's the same object 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

714 _generics.set_cached_generic_type(cls, typevar_values, submodel) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

715 else: 

716 parent_args = cls.__pydantic_generic_metadata__['args'] 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

717 if not parent_args: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

718 args = typevar_values 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

719 else: 

720 args = tuple(_generics.replace_types(arg, typevars_map) for arg in parent_args) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

721 

722 origin = cls.__pydantic_generic_metadata__['origin'] or cls 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

723 model_name = origin.model_parametrized_name(args) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

724 params = tuple( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

725 {param: None for param in _generics.iter_contained_typevars(typevars_map.values())} 

726 ) # use dict as ordered set 

727 

728 with _generics.generic_recursion_self_type(origin, args) as maybe_self_type: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

729 if maybe_self_type is not None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

730 return maybe_self_type 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

731 

732 cached = _generics.get_cached_generic_type_late(cls, typevar_values, origin, args) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

733 if cached is not None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

734 return cached 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

735 

736 # Attempt to rebuild the origin in case new types have been defined 

737 try: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

738 # depth 3 gets you above this __class_getitem__ call 

739 origin.model_rebuild(_parent_namespace_depth=3) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

740 except PydanticUndefinedAnnotation: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

741 # It's okay if it fails, it just means there are still undefined types 

742 # that could be evaluated later. 

743 # TODO: Make sure validation fails if there are still undefined types, perhaps using MockValidator 

744 pass 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

745 

746 submodel = _generics.create_generic_submodel(model_name, origin, args, params) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

747 

748 # Update cache 

749 _generics.set_cached_generic_type(cls, typevar_values, submodel, origin, args) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

750 

751 return submodel 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

752 

753 def __copy__(self) -> Self: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

754 """Returns a shallow copy of the model.""" 

755 cls = type(self) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

756 m = cls.__new__(cls) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

757 _object_setattr(m, '__dict__', copy(self.__dict__)) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

758 _object_setattr(m, '__pydantic_extra__', copy(self.__pydantic_extra__)) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

759 _object_setattr(m, '__pydantic_fields_set__', copy(self.__pydantic_fields_set__)) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

760 

761 if not hasattr(self, '__pydantic_private__') or self.__pydantic_private__ is None: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

762 _object_setattr(m, '__pydantic_private__', None) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

763 else: 

764 _object_setattr( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

765 m, 

766 '__pydantic_private__', 

767 {k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined}, 

768 ) 

769 

770 return m 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

771 

772 def __deepcopy__(self, memo: dict[int, Any] | None = None) -> Self: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

773 """Returns a deep copy of the model.""" 

774 cls = type(self) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

775 m = cls.__new__(cls) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

776 _object_setattr(m, '__dict__', deepcopy(self.__dict__, memo=memo)) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

777 _object_setattr(m, '__pydantic_extra__', deepcopy(self.__pydantic_extra__, memo=memo)) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

778 # This next line doesn't need a deepcopy because __pydantic_fields_set__ is a set[str], 

779 # and attempting a deepcopy would be marginally slower. 

780 _object_setattr(m, '__pydantic_fields_set__', copy(self.__pydantic_fields_set__)) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

781 

782 if not hasattr(self, '__pydantic_private__') or self.__pydantic_private__ is None: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

783 _object_setattr(m, '__pydantic_private__', None) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

784 else: 

785 _object_setattr( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

786 m, 

787 '__pydantic_private__', 

788 deepcopy({k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined}, memo=memo), 

789 ) 

790 

791 return m 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

792 

793 if not TYPE_CHECKING: 793 ↛ 898line 793 didn't jump to line 898 because the condition on line 793 was always true1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

794 # We put `__getattr__` in a non-TYPE_CHECKING block because otherwise, mypy allows arbitrary attribute access 

795 # The same goes for __setattr__ and __delattr__, see: https://github.com/pydantic/pydantic/issues/8643 

796 

797 def __getattr__(self, item: str) -> Any: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

798 private_attributes = object.__getattribute__(self, '__private_attributes__') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

799 if item in private_attributes: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

800 attribute = private_attributes[item] 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

801 if hasattr(attribute, '__get__'): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

802 return attribute.__get__(self, type(self)) # type: ignore 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

803 

804 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

805 # Note: self.__pydantic_private__ cannot be None if self.__private_attributes__ has items 

806 return self.__pydantic_private__[item] # type: ignore 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

807 except KeyError as exc: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

808 raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}') from exc 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

809 else: 

810 # `__pydantic_extra__` can fail to be set if the model is not yet fully initialized. 

811 # See `BaseModel.__repr_args__` for more details 

812 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

813 pydantic_extra = object.__getattribute__(self, '__pydantic_extra__') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

814 except AttributeError: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

815 pydantic_extra = None 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

816 

817 if pydantic_extra: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

818 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

819 return pydantic_extra[item] 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

820 except KeyError as exc: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

821 raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}') from exc 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

822 else: 

823 if hasattr(self.__class__, item): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

824 return super().__getattribute__(item) # Raises AttributeError if appropriate 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

825 else: 

826 # this is the current error 

827 raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

828 

829 def __setattr__(self, name: str, value: Any) -> None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

830 if name in self.__class_vars__: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

831 raise AttributeError( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

832 f'{name!r} is a ClassVar of `{self.__class__.__name__}` and cannot be set on an instance. ' 

833 f'If you want to set a value on the class, use `{self.__class__.__name__}.{name} = value`.' 

834 ) 

835 elif not _fields.is_valid_field_name(name): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

836 if self.__pydantic_private__ is None or name not in self.__private_attributes__: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

837 _object_setattr(self, name, value) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

838 else: 

839 attribute = self.__private_attributes__[name] 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

840 if hasattr(attribute, '__set__'): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

841 attribute.__set__(self, value) # type: ignore 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

842 else: 

843 self.__pydantic_private__[name] = value 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

844 return 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

845 

846 self._check_frozen(name, value) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

847 

848 attr = getattr(self.__class__, name, None) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

849 if isinstance(attr, property): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

850 attr.__set__(self, value) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

851 elif self.model_config.get('validate_assignment', None): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

852 self.__pydantic_validator__.validate_assignment(self, name, value) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

853 elif self.model_config.get('extra') != 'allow' and name not in self.model_fields: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

854 # TODO - matching error 

855 raise ValueError(f'"{self.__class__.__name__}" object has no field "{name}"') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

856 elif self.model_config.get('extra') == 'allow' and name not in self.model_fields: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

857 if self.model_extra and name in self.model_extra: 857 ↛ 858line 857 didn't jump to line 858 because the condition on line 857 was never true1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

858 self.__pydantic_extra__[name] = value # type: ignore 

859 else: 

860 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

861 getattr(self, name) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

862 except AttributeError: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

863 # attribute does not already exist on instance, so put it in extra 

864 self.__pydantic_extra__[name] = value # type: ignore 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

865 else: 

866 # attribute _does_ already exist on instance, and was not in extra, so update it 

867 _object_setattr(self, name, value) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

868 else: 

869 self.__dict__[name] = value 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

870 self.__pydantic_fields_set__.add(name) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

871 

872 def __delattr__(self, item: str) -> Any: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

873 if item in self.__private_attributes__: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

874 attribute = self.__private_attributes__[item] 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

875 if hasattr(attribute, '__delete__'): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

876 attribute.__delete__(self) # type: ignore 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

877 return 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

878 

879 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

880 # Note: self.__pydantic_private__ cannot be None if self.__private_attributes__ has items 

881 del self.__pydantic_private__[item] # type: ignore 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

882 return 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

883 except KeyError as exc: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

884 raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}') from exc 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

885 

886 self._check_frozen(item, None) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

887 

888 if item in self.model_fields: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

889 object.__delattr__(self, item) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

890 elif self.__pydantic_extra__ is not None and item in self.__pydantic_extra__: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

891 del self.__pydantic_extra__[item] 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

892 else: 

893 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

894 object.__delattr__(self, item) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

895 except AttributeError: 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

896 raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}') 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

897 

898 def _check_frozen(self, name: str, value: Any) -> None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

899 if self.model_config.get('frozen', None): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

900 typ = 'frozen_instance' 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

901 elif getattr(self.model_fields.get(name), 'frozen', False): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

902 typ = 'frozen_field' 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

903 else: 

904 return 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

905 error: pydantic_core.InitErrorDetails = { 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

906 'type': typ, 

907 'loc': (name,), 

908 'input': value, 

909 } 

910 raise pydantic_core.ValidationError.from_exception_data(self.__class__.__name__, [error]) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

911 

912 def __getstate__(self) -> dict[Any, Any]: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

913 private = self.__pydantic_private__ 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

914 if private: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

915 private = {k: v for k, v in private.items() if v is not PydanticUndefined} 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

916 return { 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

917 '__dict__': self.__dict__, 

918 '__pydantic_extra__': self.__pydantic_extra__, 

919 '__pydantic_fields_set__': self.__pydantic_fields_set__, 

920 '__pydantic_private__': private, 

921 } 

922 

923 def __setstate__(self, state: dict[Any, Any]) -> None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

924 _object_setattr(self, '__pydantic_fields_set__', state.get('__pydantic_fields_set__', {})) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

925 _object_setattr(self, '__pydantic_extra__', state.get('__pydantic_extra__', {})) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

926 _object_setattr(self, '__pydantic_private__', state.get('__pydantic_private__', {})) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

927 _object_setattr(self, '__dict__', state.get('__dict__', {})) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

928 

929 if not TYPE_CHECKING: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

930 

931 def __eq__(self, other: Any) -> bool: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

932 if isinstance(other, BaseModel): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

933 # When comparing instances of generic types for equality, as long as all field values are equal, 

934 # only require their generic origin types to be equal, rather than exact type equality. 

935 # This prevents headaches like MyGeneric(x=1) != MyGeneric[Any](x=1). 

936 self_type = self.__pydantic_generic_metadata__['origin'] or self.__class__ 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

937 other_type = other.__pydantic_generic_metadata__['origin'] or other.__class__ 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

938 

939 # Perform common checks first 

940 if not ( 1mqnrBuovpw

941 self_type == other_type 

942 and getattr(self, '__pydantic_private__', None) == getattr(other, '__pydantic_private__', None) 

943 and self.__pydantic_extra__ == other.__pydantic_extra__ 

944 ): 

945 return False 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

946 

947 # We only want to compare pydantic fields but ignoring fields is costly. 

948 # We'll perform a fast check first, and fallback only when needed 

949 # See GH-7444 and GH-7825 for rationale and a performance benchmark 

950 

951 # First, do the fast (and sometimes faulty) __dict__ comparison 

952 if self.__dict__ == other.__dict__: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

953 # If the check above passes, then pydantic fields are equal, we can return early 

954 return True 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

955 

956 # We don't want to trigger unnecessary costly filtering of __dict__ on all unequal objects, so we return 

957 # early if there are no keys to ignore (we would just return False later on anyway) 

958 model_fields = type(self).model_fields.keys() 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

959 if self.__dict__.keys() <= model_fields and other.__dict__.keys() <= model_fields: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

960 return False 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

961 

962 # If we reach here, there are non-pydantic-fields keys, mapped to unequal values, that we need to ignore 

963 # Resort to costly filtering of the __dict__ objects 

964 # We use operator.itemgetter because it is much faster than dict comprehensions 

965 # NOTE: Contrary to standard python class and instances, when the Model class has a default value for an 

966 # attribute and the model instance doesn't have a corresponding attribute, accessing the missing attribute 

967 # raises an error in BaseModel.__getattr__ instead of returning the class attribute 

968 # So we can use operator.itemgetter() instead of operator.attrgetter() 

969 getter = operator.itemgetter(*model_fields) if model_fields else lambda _: _utils._SENTINEL 969 ↛ exitline 969 didn't run the lambda on line 9691mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

970 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

971 return getter(self.__dict__) == getter(other.__dict__) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

972 except KeyError: 

973 # In rare cases (such as when using the deprecated BaseModel.copy() method), 

974 # the __dict__ may not contain all model fields, which is how we can get here. 

975 # getter(self.__dict__) is much faster than any 'safe' method that accounts 

976 # for missing keys, and wrapping it in a `try` doesn't slow things down much 

977 # in the common case. 

978 self_fields_proxy = _utils.SafeGetItemProxy(self.__dict__) 

979 other_fields_proxy = _utils.SafeGetItemProxy(other.__dict__) 

980 return getter(self_fields_proxy) == getter(other_fields_proxy) 

981 

982 # other instance is not a BaseModel 

983 else: 

984 return NotImplemented # delegate to the other item in the comparison 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

985 

986 if TYPE_CHECKING: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

987 # We put `__init_subclass__` in a TYPE_CHECKING block because, even though we want the type-checking benefits 

988 # described in the signature of `__init_subclass__` below, we don't want to modify the default behavior of 

989 # subclass initialization. 

990 

991 def __init_subclass__(cls, **kwargs: Unpack[ConfigDict]): 

992 """This signature is included purely to help type-checkers check arguments to class declaration, which 

993 provides a way to conveniently set model_config key/value pairs. 

994 

995 ```py 

996 from pydantic import BaseModel 

997 

998 class MyModel(BaseModel, extra='allow'): 

999 ... 

1000 ``` 

1001 

1002 However, this may be deceiving, since the _actual_ calls to `__init_subclass__` will not receive any 

1003 of the config arguments, and will only receive any keyword arguments passed during class initialization 

1004 that are _not_ expected keys in ConfigDict. (This is due to the way `ModelMetaclass.__new__` works.) 

1005 

1006 Args: 

1007 **kwargs: Keyword arguments passed to the class definition, which set model_config 

1008 

1009 Note: 

1010 You may want to override `__pydantic_init_subclass__` instead, which behaves similarly but is called 

1011 *after* the class is fully initialized. 

1012 """ 

1013 

1014 def __iter__(self) -> TupleGenerator: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1015 """So `dict(model)` works.""" 

1016 yield from [(k, v) for (k, v) in self.__dict__.items() if not k.startswith('_')] 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1017 extra = self.__pydantic_extra__ 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1018 if extra: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1019 yield from extra.items() 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1020 

1021 def __repr__(self) -> str: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1022 return f'{self.__repr_name__()}({self.__repr_str__(", ")})' 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1023 

1024 def __repr_args__(self) -> _repr.ReprArgs: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1025 for k, v in self.__dict__.items(): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1026 field = self.model_fields.get(k) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1027 if field and field.repr: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1028 yield k, v 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1029 

1030 # `__pydantic_extra__` can fail to be set if the model is not yet fully initialized. 

1031 # This can happen if a `ValidationError` is raised during initialization and the instance's 

1032 # repr is generated as part of the exception handling. Therefore, we use `getattr` here 

1033 # with a fallback, even though the type hints indicate the attribute will always be present. 

1034 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1035 pydantic_extra = object.__getattribute__(self, '__pydantic_extra__') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1036 except AttributeError: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1037 pydantic_extra = None 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1038 

1039 if pydantic_extra is not None: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1040 yield from ((k, v) for k, v in pydantic_extra.items()) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1041 yield from ((k, getattr(self, k)) for k, v in self.model_computed_fields.items() if v.repr) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1042 

1043 # take logic from `_repr.Representation` without the side effects of inheritance, see #5740 

1044 __repr_name__ = _repr.Representation.__repr_name__ 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1045 __repr_str__ = _repr.Representation.__repr_str__ 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1046 __pretty__ = _repr.Representation.__pretty__ 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1047 __rich_repr__ = _repr.Representation.__rich_repr__ 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1048 

1049 def __str__(self) -> str: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1050 return self.__repr_str__(' ') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1051 

1052 # ##### Deprecated methods from v1 ##### 

1053 @property 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1054 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1055 'The `__fields__` attribute is deprecated, use `model_fields` instead.', category=None 

1056 ) 

1057 def __fields__(self) -> dict[str, FieldInfo]: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1058 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1059 'The `__fields__` attribute is deprecated, use `model_fields` instead.', category=PydanticDeprecatedSince20 

1060 ) 

1061 return self.model_fields 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1062 

1063 @property 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1064 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1065 'The `__fields_set__` attribute is deprecated, use `model_fields_set` instead.', 

1066 category=None, 

1067 ) 

1068 def __fields_set__(self) -> set[str]: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1069 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1070 'The `__fields_set__` attribute is deprecated, use `model_fields_set` instead.', 

1071 category=PydanticDeprecatedSince20, 

1072 ) 

1073 return self.__pydantic_fields_set__ 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1074 

1075 @typing_extensions.deprecated('The `dict` method is deprecated; use `model_dump` instead.', category=None) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1076 def dict( # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1077 self, 

1078 *, 

1079 include: IncEx = None, 

1080 exclude: IncEx = None, 

1081 by_alias: bool = False, 

1082 exclude_unset: bool = False, 

1083 exclude_defaults: bool = False, 

1084 exclude_none: bool = False, 

1085 ) -> Dict[str, Any]: # noqa UP006 

1086 warnings.warn('The `dict` method is deprecated; use `model_dump` instead.', category=PydanticDeprecatedSince20) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1087 return self.model_dump( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1088 include=include, 

1089 exclude=exclude, 

1090 by_alias=by_alias, 

1091 exclude_unset=exclude_unset, 

1092 exclude_defaults=exclude_defaults, 

1093 exclude_none=exclude_none, 

1094 ) 

1095 

1096 @typing_extensions.deprecated('The `json` method is deprecated; use `model_dump_json` instead.', category=None) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1097 def json( # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1098 self, 

1099 *, 

1100 include: IncEx = None, 

1101 exclude: IncEx = None, 

1102 by_alias: bool = False, 

1103 exclude_unset: bool = False, 

1104 exclude_defaults: bool = False, 

1105 exclude_none: bool = False, 

1106 encoder: Callable[[Any], Any] | None = PydanticUndefined, # type: ignore[assignment] 

1107 models_as_dict: bool = PydanticUndefined, # type: ignore[assignment] 

1108 **dumps_kwargs: Any, 

1109 ) -> str: 

1110 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1111 'The `json` method is deprecated; use `model_dump_json` instead.', category=PydanticDeprecatedSince20 

1112 ) 

1113 if encoder is not PydanticUndefined: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1114 raise TypeError('The `encoder` argument is no longer supported; use field serializers instead.') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1115 if models_as_dict is not PydanticUndefined: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1116 raise TypeError('The `models_as_dict` argument is no longer supported; use a model serializer instead.') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1117 if dumps_kwargs: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1118 raise TypeError('`dumps_kwargs` keyword arguments are no longer supported.') 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1119 return self.model_dump_json( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1120 include=include, 

1121 exclude=exclude, 

1122 by_alias=by_alias, 

1123 exclude_unset=exclude_unset, 

1124 exclude_defaults=exclude_defaults, 

1125 exclude_none=exclude_none, 

1126 ) 

1127 

1128 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1129 @typing_extensions.deprecated('The `parse_obj` method is deprecated; use `model_validate` instead.', category=None) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1130 def parse_obj(cls, obj: Any) -> Self: # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1131 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1132 'The `parse_obj` method is deprecated; use `model_validate` instead.', category=PydanticDeprecatedSince20 

1133 ) 

1134 return cls.model_validate(obj) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1135 

1136 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1137 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1138 'The `parse_raw` method is deprecated; if your data is JSON use `model_validate_json`, ' 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1139 'otherwise load the data then use `model_validate` instead.', 

1140 category=None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1141 ) 

1142 def parse_raw( # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1143 cls, 

1144 b: str | bytes, 1acdeBufghiMNbjkl

1145 *, 

1146 content_type: str | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1147 encoding: str = 'utf8', 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1148 proto: DeprecatedParseProtocol | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1149 allow_pickle: bool = False, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1150 ) -> Self: # pragma: no cover 1acdeBufghiMNbjkl

1151 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1152 'The `parse_raw` method is deprecated; if your data is JSON use `model_validate_json`, ' 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1153 'otherwise load the data then use `model_validate` instead.', 

1154 category=PydanticDeprecatedSince20, 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1155 ) 

1156 from .deprecated import parse 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1157 

1158 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1159 obj = parse.load_str_bytes( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1160 b, 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1161 proto=proto, 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1162 content_type=content_type, 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1163 encoding=encoding, 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1164 allow_pickle=allow_pickle, 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1165 ) 

1166 except (ValueError, TypeError) as exc: 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1167 import json 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1168 

1169 # try to match V1 

1170 if isinstance(exc, UnicodeDecodeError): 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1171 type_str = 'value_error.unicodedecode' 

1172 elif isinstance(exc, json.JSONDecodeError): 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1173 type_str = 'value_error.jsondecode' 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1174 elif isinstance(exc, ValueError): 

1175 type_str = 'value_error' 

1176 else: 

1177 type_str = 'type_error' 

1178 

1179 # ctx is missing here, but since we've added `input` to the error, we're not pretending it's the same 

1180 error: pydantic_core.InitErrorDetails = { 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1181 # The type: ignore on the next line is to ignore the requirement of LiteralString 

1182 'type': pydantic_core.PydanticCustomError(type_str, str(exc)), # type: ignore 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1183 'loc': ('__root__',), 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1184 'input': b, 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1185 } 

1186 raise pydantic_core.ValidationError.from_exception_data(cls.__name__, [error]) 1mqnrsztAacdeCDEFGHIJfghiovpwxKyLbjkl

1187 return cls.model_validate(obj) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1188 

1189 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1190 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1191 'The `parse_file` method is deprecated; load the data from file, then if your data is JSON ' 

1192 'use `model_validate_json`, otherwise `model_validate` instead.', 

1193 category=None, 

1194 ) 

1195 def parse_file( # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1196 cls, 

1197 path: str | Path, 

1198 *, 

1199 content_type: str | None = None, 

1200 encoding: str = 'utf8', 

1201 proto: DeprecatedParseProtocol | None = None, 

1202 allow_pickle: bool = False, 

1203 ) -> Self: 

1204 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1205 'The `parse_file` method is deprecated; load the data from file, then if your data is JSON ' 

1206 'use `model_validate_json`, otherwise `model_validate` instead.', 

1207 category=PydanticDeprecatedSince20, 

1208 ) 

1209 from .deprecated import parse 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1210 

1211 obj = parse.load_file( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1212 path, 

1213 proto=proto, 

1214 content_type=content_type, 

1215 encoding=encoding, 

1216 allow_pickle=allow_pickle, 

1217 ) 

1218 return cls.parse_obj(obj) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1219 

1220 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1221 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1222 'The `from_orm` method is deprecated; set ' 

1223 "`model_config['from_attributes']=True` and use `model_validate` instead.", 

1224 category=None, 

1225 ) 

1226 def from_orm(cls, obj: Any) -> Self: # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1227 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1228 'The `from_orm` method is deprecated; set ' 

1229 "`model_config['from_attributes']=True` and use `model_validate` instead.", 

1230 category=PydanticDeprecatedSince20, 

1231 ) 

1232 if not cls.model_config.get('from_attributes', None): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1233 raise PydanticUserError( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1234 'You must set the config attribute `from_attributes=True` to use from_orm', code=None 

1235 ) 

1236 return cls.model_validate(obj) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1237 

1238 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1239 @typing_extensions.deprecated('The `construct` method is deprecated; use `model_construct` instead.', category=None) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1240 def construct(cls, _fields_set: set[str] | None = None, **values: Any) -> Self: # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1241 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1242 'The `construct` method is deprecated; use `model_construct` instead.', category=PydanticDeprecatedSince20 

1243 ) 

1244 return cls.model_construct(_fields_set=_fields_set, **values) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1245 

1246 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1247 'The `copy` method is deprecated; use `model_copy` instead. ' 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1248 'See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.', 

1249 category=None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1250 ) 

1251 def copy( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1252 self, 

1253 *, 

1254 include: AbstractSetIntStr | MappingIntStrAny | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1255 exclude: AbstractSetIntStr | MappingIntStrAny | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1256 update: Dict[str, Any] | None = None, # noqa UP006 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1257 deep: bool = False, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1258 ) -> Self: # pragma: no cover 1acdeBufghiMNbjkl

1259 """Returns a copy of the model. 

1260 

1261 !!! warning "Deprecated" 

1262 This method is now deprecated; use `model_copy` instead. 

1263 

1264 If you need `include` or `exclude`, use: 

1265 

1266 ```py 

1267 data = self.model_dump(include=include, exclude=exclude, round_trip=True) 

1268 data = {**data, **(update or {})} 

1269 copied = self.model_validate(data) 

1270 ``` 

1271 

1272 Args: 

1273 include: Optional set or mapping specifying which fields to include in the copied model. 

1274 exclude: Optional set or mapping specifying which fields to exclude in the copied model. 

1275 update: Optional dictionary of field-value pairs to override field values in the copied model. 

1276 deep: If True, the values of fields that are Pydantic models will be deep-copied. 

1277 

1278 Returns: 

1279 A copy of the model with included, excluded and updated fields as specified. 

1280 """ 

1281 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1282 'The `copy` method is deprecated; use `model_copy` instead. ' 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1283 'See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.', 

1284 category=PydanticDeprecatedSince20, 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1285 ) 

1286 from .deprecated import copy_internals 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1287 

1288 values = dict( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1289 copy_internals._iter( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1290 self, to_dict=False, by_alias=False, include=include, exclude=exclude, exclude_unset=False 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1291 ), 

1292 **(update or {}), 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1293 ) 

1294 if self.__pydantic_private__ is None: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1295 private = None 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1296 else: 

1297 private = {k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined} 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1298 

1299 if self.__pydantic_extra__ is None: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1300 extra: dict[str, Any] | None = None 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1301 else: 

1302 extra = self.__pydantic_extra__.copy() 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1303 for k in list(self.__pydantic_extra__): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1304 if k not in values: # k was in the exclude 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1305 extra.pop(k) 

1306 for k in list(values): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1307 if k in self.__pydantic_extra__: # k must have come from extra 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1308 extra[k] = values.pop(k) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1309 

1310 # new `__pydantic_fields_set__` can have unset optional fields with a set value in `update` kwarg 

1311 if update: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1312 fields_set = self.__pydantic_fields_set__ | update.keys() 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1313 else: 

1314 fields_set = set(self.__pydantic_fields_set__) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1315 

1316 # removing excluded fields from `__pydantic_fields_set__` 

1317 if exclude: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1318 fields_set -= set(exclude) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1319 

1320 return copy_internals._copy_and_set_values(self, values, fields_set, extra, private, deep=deep) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1321 

1322 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1323 @typing_extensions.deprecated('The `schema` method is deprecated; use `model_json_schema` instead.', category=None) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1324 def schema( # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1325 cls, by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE 

1326 ) -> Dict[str, Any]: # noqa UP006 

1327 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1328 'The `schema` method is deprecated; use `model_json_schema` instead.', category=PydanticDeprecatedSince20 

1329 ) 

1330 return cls.model_json_schema(by_alias=by_alias, ref_template=ref_template) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1331 

1332 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1333 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1334 'The `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.', 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1335 category=None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1336 ) 

1337 def schema_json( # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1338 cls, *, by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE, **dumps_kwargs: Any 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1339 ) -> str: # pragma: no cover 1acdeBufghiMNbjkl

1340 warnings.warn( 

1341 'The `schema_json` method is deprecated; use `model_json_schema` and json.dumps instead.', 

1342 category=PydanticDeprecatedSince20, 

1343 ) 

1344 import json 

1345 

1346 from .deprecated.json import pydantic_encoder 

1347 

1348 return json.dumps( 

1349 cls.model_json_schema(by_alias=by_alias, ref_template=ref_template), 

1350 default=pydantic_encoder, 

1351 **dumps_kwargs, 

1352 ) 

1353 

1354 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1355 @typing_extensions.deprecated('The `validate` method is deprecated; use `model_validate` instead.', category=None) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1356 def validate(cls, value: Any) -> Self: # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1357 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1358 'The `validate` method is deprecated; use `model_validate` instead.', category=PydanticDeprecatedSince20 

1359 ) 

1360 return cls.model_validate(value) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1361 

1362 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1363 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1364 'The `update_forward_refs` method is deprecated; use `model_rebuild` instead.', 

1365 category=None, 

1366 ) 

1367 def update_forward_refs(cls, **localns: Any) -> None: # noqa: D102 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1368 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1369 'The `update_forward_refs` method is deprecated; use `model_rebuild` instead.', 

1370 category=PydanticDeprecatedSince20, 

1371 ) 

1372 if localns: # pragma: no cover 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1373 raise TypeError('`localns` arguments are not longer accepted.') 

1374 cls.model_rebuild(force=True) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1375 

1376 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1377 'The private method `_iter` will be removed and should no longer be used.', category=None 

1378 ) 

1379 def _iter(self, *args: Any, **kwargs: Any) -> Any: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1380 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1381 'The private method `_iter` will be removed and should no longer be used.', 

1382 category=PydanticDeprecatedSince20, 

1383 ) 

1384 from .deprecated import copy_internals 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1385 

1386 return copy_internals._iter(self, *args, **kwargs) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1387 

1388 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1389 'The private method `_copy_and_set_values` will be removed and should no longer be used.', 

1390 category=None, 

1391 ) 

1392 def _copy_and_set_values(self, *args: Any, **kwargs: Any) -> Any: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1393 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1394 'The private method `_copy_and_set_values` will be removed and should no longer be used.', 

1395 category=PydanticDeprecatedSince20, 

1396 ) 

1397 from .deprecated import copy_internals 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1398 

1399 return copy_internals._copy_and_set_values(self, *args, **kwargs) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1400 

1401 @classmethod 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1402 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1403 'The private method `_get_value` will be removed and should no longer be used.', 

1404 category=None, 

1405 ) 

1406 def _get_value(cls, *args: Any, **kwargs: Any) -> Any: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1407 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1408 'The private method `_get_value` will be removed and should no longer be used.', 

1409 category=PydanticDeprecatedSince20, 

1410 ) 

1411 from .deprecated import copy_internals 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1412 

1413 return copy_internals._get_value(cls, *args, **kwargs) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1414 

1415 @typing_extensions.deprecated( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1416 'The private method `_calculate_keys` will be removed and should no longer be used.', 

1417 category=None, 

1418 ) 

1419 def _calculate_keys(self, *args: Any, **kwargs: Any) -> Any: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1420 warnings.warn( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1421 'The private method `_calculate_keys` will be removed and should no longer be used.', 

1422 category=PydanticDeprecatedSince20, 

1423 ) 

1424 from .deprecated import copy_internals 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1425 

1426 return copy_internals._calculate_keys(self, *args, **kwargs) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1427 

1428 

1429@overload 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1430def create_model( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1431 model_name: str, 1acdeBufghiMNbjkl

1432 /, 

1433 *, 

1434 __config__: ConfigDict | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1435 __doc__: str | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1436 __base__: None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1437 __module__: str = __name__, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1438 __validators__: dict[str, Callable[..., Any]] | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1439 __cls_kwargs__: dict[str, Any] | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1440 **field_definitions: Any, 1acdeBufghiMNbjkl

1441) -> type[BaseModel]: ... 1acdeBufghiMNbjkl

1442 

1443 

1444@overload 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1445def create_model( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1446 model_name: str, 1acdeBufghiMNbjkl

1447 /, 

1448 *, 

1449 __config__: ConfigDict | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1450 __doc__: str | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1451 __base__: type[ModelT] | tuple[type[ModelT], ...], 1acdeBufghiMNbjkl

1452 __module__: str = __name__, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1453 __validators__: dict[str, Callable[..., Any]] | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1454 __cls_kwargs__: dict[str, Any] | None = None, 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1455 **field_definitions: Any, 1acdeBufghiMNbjkl

1456) -> type[ModelT]: ... 1acdeBufghiMNbjkl

1457 

1458 

1459def create_model( # noqa: C901 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1460 model_name: str, 

1461 /, 

1462 *, 

1463 __config__: ConfigDict | None = None, 

1464 __doc__: str | None = None, 

1465 __base__: type[ModelT] | tuple[type[ModelT], ...] | None = None, 

1466 __module__: str | None = None, 

1467 __validators__: dict[str, Callable[..., Any]] | None = None, 

1468 __cls_kwargs__: dict[str, Any] | None = None, 

1469 __slots__: tuple[str, ...] | None = None, 

1470 **field_definitions: Any, 

1471) -> type[ModelT]: 

1472 """Usage docs: https://docs.pydantic.dev/2.8/concepts/models/#dynamic-model-creation 

1473 

1474 Dynamically creates and returns a new Pydantic model, in other words, `create_model` dynamically creates a 

1475 subclass of [`BaseModel`][pydantic.BaseModel]. 

1476 

1477 Args: 

1478 model_name: The name of the newly created model. 

1479 __config__: The configuration of the new model. 

1480 __doc__: The docstring of the new model. 

1481 __base__: The base class or classes for the new model. 

1482 __module__: The name of the module that the model belongs to; 

1483 if `None`, the value is taken from `sys._getframe(1)` 

1484 __validators__: A dictionary of methods that validate fields. The keys are the names of the validation methods to 

1485 be added to the model, and the values are the validation methods themselves. You can read more about functional 

1486 validators [here](https://docs.pydantic.dev/2.8/concepts/validators/#field-validators). 

1487 __cls_kwargs__: A dictionary of keyword arguments for class creation, such as `metaclass`. 

1488 __slots__: Deprecated. Should not be passed to `create_model`. 

1489 **field_definitions: Attributes of the new model. They should be passed in the format: 

1490 `<name>=(<type>, <default value>)`, `<name>=(<type>, <FieldInfo>)`, or `typing.Annotated[<type>, <FieldInfo>]`. 

1491 Any additional metadata in `typing.Annotated[<type>, <FieldInfo>, ...]` will be ignored. 

1492 

1493 Returns: 

1494 The new [model][pydantic.BaseModel]. 

1495 

1496 Raises: 

1497 PydanticUserError: If `__base__` and `__config__` are both passed. 

1498 """ 

1499 if __slots__ is not None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1500 # __slots__ will be ignored from here on 

1501 warnings.warn('__slots__ should not be passed to create_model', RuntimeWarning) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1502 

1503 if __base__ is not None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1504 if __config__ is not None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1505 raise PydanticUserError( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1506 'to avoid confusion `__config__` and `__base__` cannot be used together', 

1507 code='create-model-config-base', 

1508 ) 

1509 if not isinstance(__base__, tuple): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1510 __base__ = (__base__,) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1511 else: 

1512 __base__ = (cast('type[ModelT]', BaseModel),) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1513 

1514 __cls_kwargs__ = __cls_kwargs__ or {} 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1515 

1516 fields = {} 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1517 annotations = {} 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1518 

1519 for f_name, f_def in field_definitions.items(): 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1520 if not _fields.is_valid_field_name(f_name): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1521 warnings.warn(f'fields may not start with an underscore, ignoring "{f_name}"', RuntimeWarning) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1522 if isinstance(f_def, tuple): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1523 f_def = cast('tuple[str, Any]', f_def) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1524 try: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1525 f_annotation, f_value = f_def 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1526 except ValueError as e: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1527 raise PydanticUserError( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1528 'Field definitions should be a `(<type>, <default>)`.', 

1529 code='create-model-field-definitions', 

1530 ) from e 

1531 

1532 elif _typing_extra.is_annotated(f_def): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1533 (f_annotation, f_value, *_) = typing_extensions.get_args( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1534 f_def 

1535 ) # first two input are expected from Annotated, refer to https://docs.python.org/3/library/typing.html#typing.Annotated 

1536 from .fields import FieldInfo 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1537 

1538 if not isinstance(f_value, FieldInfo): 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1539 raise PydanticUserError( 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1540 'Field definitions should be a Annotated[<type>, <FieldInfo>]', 

1541 code='create-model-field-definitions', 

1542 ) 

1543 

1544 else: 

1545 f_annotation, f_value = None, f_def 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1546 

1547 if f_annotation: 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1548 annotations[f_name] = f_annotation 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1549 fields[f_name] = f_value 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1550 

1551 if __module__ is None: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1552 f = sys._getframe(1) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1553 __module__ = f.f_globals['__name__'] 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1554 

1555 namespace: dict[str, Any] = {'__annotations__': annotations, '__module__': __module__} 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1556 if __doc__: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1557 namespace.update({'__doc__': __doc__}) 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1558 if __validators__: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1559 namespace.update(__validators__) 1mnstaopxyb

1560 namespace.update(fields) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1561 if __config__: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1562 namespace['model_config'] = _config.ConfigWrapper(__config__).config_dict 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1563 resolved_bases = types.resolve_bases(__base__) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1564 meta, ns, kwds = types.prepare_class(model_name, resolved_bases, kwds=__cls_kwargs__) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1565 if resolved_bases is not __base__: 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1566 ns['__orig_bases__'] = __base__ 1mqnrsztAacdeBuCDEFGHIJfghiovpwxKyLbjkl

1567 namespace.update(ns) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1568 

1569 return meta( 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl

1570 model_name, 

1571 resolved_bases, 

1572 namespace, 

1573 __pydantic_reset_parent_namespace__=False, 

1574 _create_model_module=__module__, 

1575 **kwds, 

1576 ) 

1577 

1578 

1579__getattr__ = getattr_migration(__name__) 1mqnrsztAacdeBuCDEFGHIJfghiOPQRSTUVMNovpwxKyLbjkl