Coverage for pydantic/_internal/_model_construction.py: 98.97%

1"""Private logic for creating models.""" 

2 

3from __future__ import annotations as _annotations 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

4 

5import builtins 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

6import operator 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

7import sys 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

8import typing 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

9import warnings 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

10import weakref 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

11from abc import ABCMeta 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

12from functools import cache, partial, wraps 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

13from types import FunctionType 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

14from typing import Any, Callable, Generic, Literal, NoReturn, cast 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

15 

16from pydantic_core import PydanticUndefined, SchemaSerializer 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

17from typing_extensions import TypeAliasType, dataclass_transform, deprecated, get_args, get_origin 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

18from typing_inspection import typing_objects 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

19 

20from ..errors import PydanticUndefinedAnnotation, PydanticUserError 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

21from ..plugin._schema_validator import create_schema_validator 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

22from ..warnings import GenericBeforeBaseModelWarning, PydanticDeprecatedSince20 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

23from ._config import ConfigWrapper 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

24from ._decorators import DecoratorInfos, PydanticDescriptorProxy, get_attribute_from_bases, unwrap_wrapped_function 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

25from ._fields import collect_model_fields, is_valid_field_name, is_valid_privateattr_name, rebuild_model_fields 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

26from ._generate_schema import GenerateSchema, InvalidSchemaError 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

27from ._generics import PydanticGenericMetadata, get_model_typevars_map 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

28from ._import_utils import import_cached_base_model, import_cached_field_info 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

29from ._mock_val_ser import set_model_mocks 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

30from ._namespace_utils import NsResolver 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

31from ._signature import generate_pydantic_signature 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

32from ._typing_extra import ( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

33 _make_forward_ref, 

34 eval_type_backport, 

35 is_classvar_annotation, 

36 parent_frame_namespace, 

37) 

38from ._utils import LazyClassAttribute, SafeGetItemProxy 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

39 

40if typing.TYPE_CHECKING: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

41 from ..fields import Field as PydanticModelField 

42 from ..fields import FieldInfo, ModelPrivateAttr 

43 from ..fields import PrivateAttr as PydanticModelPrivateAttr 

44 from ..main import BaseModel 

45else: 

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

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

48 DeprecationWarning = PydanticDeprecatedSince20 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

49 PydanticModelField = object() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

50 PydanticModelPrivateAttr = object() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

51 

52object_setattr = object.__setattr__ 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

53 

54 

55class _ModelNamespaceDict(dict): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

56 """A dictionary subclass that intercepts attribute setting on model classes and 

57 warns about overriding of decorators. 

58 """ 

59 

60 def __setitem__(self, k: str, v: object) -> None: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

61 existing: Any = self.get(k, None) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

62 if existing and v is not existing and isinstance(existing, PydanticDescriptorProxy): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

63 warnings.warn(f'`{k}` overrides an existing Pydantic `{existing.decorator_info.decorator_repr}` decorator') 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

64 

65 return super().__setitem__(k, v) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

66 

67 

68def NoInitField( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

69 *, 

70 init: Literal[False] = False, 

71) -> Any: 

72 """Only for typing purposes. Used as default value of `__pydantic_fields_set__`, 

73 `__pydantic_extra__`, `__pydantic_private__`, so they could be ignored when 

74 synthesizing the `__init__` signature. 

75 """ 

76 

77 

78@dataclass_transform(kw_only_default=True, field_specifiers=(PydanticModelField, PydanticModelPrivateAttr, NoInitField)) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

79class ModelMetaclass(ABCMeta): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

80 def __new__( 40 ctx1adeofpqArBCbijsktuDvEFJKLMNOPclmwnxyGzHI

81 mcs, 

82 cls_name: str, 

83 bases: tuple[type[Any], ...], 

84 namespace: dict[str, Any], 

85 __pydantic_generic_metadata__: PydanticGenericMetadata | None = None, 

86 __pydantic_reset_parent_namespace__: bool = True, 

87 _create_model_module: str | None = None, 

88 **kwargs: Any, 

89 ) -> type: 

90 """Metaclass for creating Pydantic models. 

91 

92 Args: 

93 cls_name: The name of the class to be created. 

94 bases: The base classes of the class to be created. 

95 namespace: The attribute dictionary of the class to be created. 

96 __pydantic_generic_metadata__: Metadata for generic models. 

97 __pydantic_reset_parent_namespace__: Reset parent namespace. 

98 _create_model_module: The module of the class to be created, if created by `create_model`. 

99 **kwargs: Catch-all for any other keyword arguments. 

100 

101 Returns: 

102 The new class created by the metaclass. 

103 """ 

104 # Note `ModelMetaclass` refers to `BaseModel`, but is also used to *create* `BaseModel`, so we rely on the fact 

105 # that `BaseModel` itself won't have any bases, but any subclass of it will, to determine whether the `__new__` 

106 # call we're in the middle of is for the `BaseModel` class. 

107 if bases: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

108 base_field_names, class_vars, base_private_attributes = mcs._collect_bases_data(bases) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

109 

110 config_wrapper = ConfigWrapper.for_model(bases, namespace, kwargs) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

111 namespace['model_config'] = config_wrapper.config_dict 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

112 private_attributes = inspect_namespace( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

113 namespace, config_wrapper.ignored_types, class_vars, base_field_names 

114 ) 

115 if private_attributes or base_private_attributes: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

116 original_model_post_init = get_model_post_init(namespace, bases) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

117 if original_model_post_init is not None: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

118 # if there are private_attributes and a model_post_init function, we handle both 

119 

120 @wraps(original_model_post_init) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

121 def wrapped_model_post_init(self: BaseModel, context: Any, /) -> None: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

122 """We need to both initialize private attributes and call the user-defined model_post_init 

123 method. 

124 """ 

125 init_private_attributes(self, context) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

126 original_model_post_init(self, context) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

127 

128 namespace['model_post_init'] = wrapped_model_post_init 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

129 else: 

130 namespace['model_post_init'] = init_private_attributes 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

131 

132 namespace['__class_vars__'] = class_vars 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

133 namespace['__private_attributes__'] = {**base_private_attributes, **private_attributes} 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

134 

135 cls = cast('type[BaseModel]', super().__new__(mcs, cls_name, bases, namespace, **kwargs)) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

136 BaseModel_ = import_cached_base_model() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

137 

138 mro = cls.__mro__ 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

139 if Generic in mro and mro.index(Generic) < mro.index(BaseModel_): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

140 warnings.warn( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

141 GenericBeforeBaseModelWarning( 

142 'Classes should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) ' 

143 'for pydantic generics to work properly.' 

144 ), 

145 stacklevel=2, 

146 ) 

147 

148 cls.__pydantic_custom_init__ = not getattr(cls.__init__, '__pydantic_base_init__', False) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

149 cls.__pydantic_post_init__ = ( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

150 None if cls.model_post_init is BaseModel_.model_post_init else 'model_post_init' 

151 ) 

152 

153 cls.__pydantic_setattr_handlers__ = {} 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

154 

155 cls.__pydantic_decorators__ = DecoratorInfos.build(cls) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

156 cls.__pydantic_decorators__.update_from_config(config_wrapper) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

157 

158 # Use the getattr below to grab the __parameters__ from the `typing.Generic` parent class 

159 if __pydantic_generic_metadata__: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

160 cls.__pydantic_generic_metadata__ = __pydantic_generic_metadata__ 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

161 else: 

162 parent_parameters = getattr(cls, '__pydantic_generic_metadata__', {}).get('parameters', ()) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

163 parameters = getattr(cls, '__parameters__', None) or parent_parameters 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

164 if parameters and parent_parameters and not all(x in parameters for x in parent_parameters): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

165 from ..root_model import RootModelRootType 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

166 

167 missing_parameters = tuple(x for x in parameters if x not in parent_parameters) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

168 if RootModelRootType in parent_parameters and RootModelRootType not in parameters: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

169 # This is a special case where the user has subclassed `RootModel`, but has not parametrized 

170 # RootModel with the generic type identifiers being used. Ex: 

171 # class MyModel(RootModel, Generic[T]): 

172 # root: T 

173 # Should instead just be: 

174 # class MyModel(RootModel[T]): 

175 # root: T 

176 parameters_str = ', '.join([x.__name__ for x in missing_parameters]) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

177 error_message = ( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

178 f'{cls.__name__} is a subclass of `RootModel`, but does not include the generic type identifier(s) ' 

179 f'{parameters_str} in its parameters. ' 

180 f'You should parametrize RootModel directly, e.g., `class {cls.__name__}(RootModel[{parameters_str}]): ...`.' 

181 ) 

182 else: 

183 combined_parameters = parent_parameters + missing_parameters 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

184 parameters_str = ', '.join([str(x) for x in combined_parameters]) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

185 generic_type_label = f'typing.Generic[{parameters_str}]' 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

186 error_message = ( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

187 f'All parameters must be present on typing.Generic;' 

188 f' you should inherit from {generic_type_label}.' 

189 ) 

190 if Generic not in bases: # pragma: no cover 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

191 # We raise an error here not because it is desirable, but because some cases are mishandled. 

192 # It would be nice to remove this error and still have things behave as expected, it's just 

193 # challenging because we are using a custom `__class_getitem__` to parametrize generic models, 

194 # and not returning a typing._GenericAlias from it. 

195 bases_str = ', '.join([x.__name__ for x in bases] + [generic_type_label]) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

196 error_message += ( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

197 f' Note: `typing.Generic` must go last: `class {cls.__name__}({bases_str}): ...`)' 

198 ) 

199 raise TypeError(error_message) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

200 

201 cls.__pydantic_generic_metadata__ = { 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

202 'origin': None, 

203 'args': (), 

204 'parameters': parameters, 

205 } 

206 

207 cls.__pydantic_complete__ = False # Ensure this specific class gets completed 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

208 

209 # preserve `__set_name__` protocol defined in https://peps.python.org/pep-0487 

210 # for attributes not in `new_namespace` (e.g. private attributes) 

211 for name, obj in private_attributes.items(): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

212 obj.__set_name__(cls, name) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

213 

214 if __pydantic_reset_parent_namespace__: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

215 cls.__pydantic_parent_namespace__ = build_lenient_weakvaluedict(parent_frame_namespace()) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

216 parent_namespace: dict[str, Any] | None = getattr(cls, '__pydantic_parent_namespace__', None) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

217 if isinstance(parent_namespace, dict): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

218 parent_namespace = unpack_lenient_weakvaluedict(parent_namespace) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

219 

220 ns_resolver = NsResolver(parent_namespace=parent_namespace) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

221 

222 set_model_fields(cls, config_wrapper=config_wrapper, ns_resolver=ns_resolver) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

223 

224 # This is also set in `complete_model_class()`, after schema gen because they are recreated. 

225 # We set them here as well for backwards compatibility: 

226 cls.__pydantic_computed_fields__ = { 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

227 k: v.info for k, v in cls.__pydantic_decorators__.computed_fields.items() 

228 } 

229 

230 if config_wrapper.defer_build: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

231 set_model_mocks(cls) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

232 else: 

233 # Any operation that requires accessing the field infos instances should be put inside 

234 # `complete_model_class()`: 

235 complete_model_class( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

236 cls, 

237 config_wrapper, 

238 ns_resolver, 

239 raise_errors=False, 

240 create_model_module=_create_model_module, 

241 ) 

242 

243 if config_wrapper.frozen and '__hash__' not in namespace: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

244 set_default_hash_func(cls, bases) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

245 

246 # using super(cls, cls) on the next line ensures we only call the parent class's __pydantic_init_subclass__ 

247 # I believe the `type: ignore` is only necessary because mypy doesn't realize that this code branch is 

248 # only hit for _proper_ subclasses of BaseModel 

249 super(cls, cls).__pydantic_init_subclass__(**kwargs) # type: ignore[misc] 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

250 return cls 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

251 else: 

252 # These are instance variables, but have been assigned to `NoInitField` to trick the type checker. 

253 for instance_slot in '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__': 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

254 namespace.pop( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

255 instance_slot, 

256 None, # In case the metaclass is used with a class other than `BaseModel`. 

257 ) 

258 namespace.get('__annotations__', {}).clear() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

259 return super().__new__(mcs, cls_name, bases, namespace, **kwargs) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

260 

261 if not typing.TYPE_CHECKING: # pragma: no branch 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

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

263 

264 def __getattr__(self, item: str) -> Any: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

265 """This is necessary to keep attribute access working for class attribute access.""" 

266 private_attributes = self.__dict__.get('__private_attributes__') 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

267 if private_attributes and item in private_attributes: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

268 return private_attributes[item] 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

269 raise AttributeError(item) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

270 

271 @classmethod 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

272 def __prepare__(cls, *args: Any, **kwargs: Any) -> dict[str, object]: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

273 return _ModelNamespaceDict() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

274 

275 def __instancecheck__(self, instance: Any) -> bool: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

276 """Avoid calling ABC _abc_instancecheck unless we're pretty sure. 

277 

278 See #3829 and python/cpython#92810 

279 """ 

280 return hasattr(instance, '__pydantic_decorators__') and super().__instancecheck__(instance) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

281 

282 def __subclasscheck__(self, subclass: type[Any]) -> bool: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

283 """Avoid calling ABC _abc_subclasscheck unless we're pretty sure. 

284 

285 See #3829 and python/cpython#92810 

286 """ 

287 return hasattr(subclass, '__pydantic_decorators__') and super().__subclasscheck__(subclass) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

288 

289 @staticmethod 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

290 def _collect_bases_data(bases: tuple[type[Any], ...]) -> tuple[set[str], set[str], dict[str, ModelPrivateAttr]]: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

291 BaseModel = import_cached_base_model() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

292 

293 field_names: set[str] = set() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

294 class_vars: set[str] = set() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

295 private_attributes: dict[str, ModelPrivateAttr] = {} 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

296 for base in bases: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

297 if issubclass(base, BaseModel) and base is not BaseModel: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

298 # model_fields might not be defined yet in the case of generics, so we use getattr here: 

299 field_names.update(getattr(base, '__pydantic_fields__', {}).keys()) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

300 class_vars.update(base.__class_vars__) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

301 private_attributes.update(base.__private_attributes__) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

302 return field_names, class_vars, private_attributes 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

303 

304 @property 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

305 @deprecated('The `__fields__` attribute is deprecated, use `model_fields` instead.', category=None) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

306 def __fields__(self) -> dict[str, FieldInfo]: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

307 warnings.warn( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

308 'The `__fields__` attribute is deprecated, use `model_fields` instead.', 

309 PydanticDeprecatedSince20, 

310 stacklevel=2, 

311 ) 

312 return getattr(self, '__pydantic_fields__', {}) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

313 

314 @property 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

315 def __pydantic_fields_complete__(self) -> bool: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

316 """Whether the fields where successfully collected (i.e. type hints were successfully resolves). 

317 

318 This is a private attribute, not meant to be used outside Pydantic. 

319 """ 

320 if not hasattr(self, '__pydantic_fields__'): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

321 return False 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

322 

323 field_infos = cast('dict[str, FieldInfo]', self.__pydantic_fields__) # pyright: ignore[reportAttributeAccessIssue] 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

324 

325 return all(field_info._complete for field_info in field_infos.values()) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

326 

327 def __dir__(self) -> list[str]: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

328 attributes = list(super().__dir__()) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

329 if '__fields__' in attributes: 329 ↛ 331line 329 didn't jump to line 331 because the condition on line 329 was always true35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

330 attributes.remove('__fields__') 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

331 return attributes 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

332 

333 

334def init_private_attributes(self: BaseModel, context: Any, /) -> None: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

335 """This function is meant to behave like a BaseModel method to initialise private attributes. 

336 

337 It takes context as an argument since that's what pydantic-core passes when calling it. 

338 

339 Args: 

340 self: The BaseModel instance. 

341 context: The context. 

342 """ 

343 if getattr(self, '__pydantic_private__', None) is None: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

344 pydantic_private = {} 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

345 for name, private_attr in self.__private_attributes__.items(): 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

346 default = private_attr.get_default() 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

347 if default is not PydanticUndefined: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

348 pydantic_private[name] = default 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

349 object_setattr(self, '__pydantic_private__', pydantic_private) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

350 

351 

352def get_model_post_init(namespace: dict[str, Any], bases: tuple[type[Any], ...]) -> Callable[..., Any] | None: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

353 """Get the `model_post_init` method from the namespace or the class bases, or `None` if not defined.""" 

354 if 'model_post_init' in namespace: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

355 return namespace['model_post_init'] 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

356 

357 BaseModel = import_cached_base_model() 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

358 

359 model_post_init = get_attribute_from_bases(bases, 'model_post_init') 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

360 if model_post_init is not BaseModel.model_post_init: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

361 return model_post_init 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

362 

363 

364def inspect_namespace( # noqa C901 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

365 namespace: dict[str, Any], 

366 ignored_types: tuple[type[Any], ...], 

367 base_class_vars: set[str], 

368 base_class_fields: set[str], 

369) -> dict[str, ModelPrivateAttr]: 

370 """Iterate over the namespace and: 

371 * gather private attributes 

372 * check for items which look like fields but are not (e.g. have no annotation) and warn. 

373 

374 Args: 

375 namespace: The attribute dictionary of the class to be created. 

376 ignored_types: A tuple of ignore types. 

377 base_class_vars: A set of base class class variables. 

378 base_class_fields: A set of base class fields. 

379 

380 Returns: 

381 A dict contains private attributes info. 

382 

383 Raises: 

384 TypeError: If there is a `__root__` field in model. 

385 NameError: If private attribute name is invalid. 

386 PydanticUserError: 

387 - If a field does not have a type annotation. 

388 - If a field on base class was overridden by a non-annotated attribute. 

389 """ 

390 from ..fields import ModelPrivateAttr, PrivateAttr 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

391 

392 FieldInfo = import_cached_field_info() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

393 

394 all_ignored_types = ignored_types + default_ignored_types() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

395 

396 private_attributes: dict[str, ModelPrivateAttr] = {} 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

397 raw_annotations = namespace.get('__annotations__', {}) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

398 

399 if '__root__' in raw_annotations or '__root__' in namespace: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

400 raise TypeError("To define root models, use `pydantic.RootModel` rather than a field called '__root__'") 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

401 

402 ignored_names: set[str] = set() 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

403 for var_name, value in list(namespace.items()): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

404 if var_name == 'model_config' or var_name == '__pydantic_extra__': 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

405 continue 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

406 elif ( 23 ctx1adeofpghbijsktJKLclmwnx

407 isinstance(value, type) 

408 and value.__module__ == namespace['__module__'] 

409 and '__qualname__' in namespace 

410 and value.__qualname__.startswith(namespace['__qualname__']) 

411 ): 

412 # `value` is a nested type defined in this namespace; don't error 

413 continue 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

414 elif isinstance(value, all_ignored_types) or value.__class__.__module__ == 'functools': 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

415 ignored_names.add(var_name) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

416 continue 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

417 elif isinstance(value, ModelPrivateAttr): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

418 if var_name.startswith('__'): 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

419 raise NameError( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

420 'Private attributes must not use dunder names;' 

421 f' use a single underscore prefix instead of {var_name!r}.' 

422 ) 

423 elif is_valid_field_name(var_name): 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

424 raise NameError( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

425 'Private attributes must not use valid field names;' 

426 f' use sunder names, e.g. {"_" + var_name!r} instead of {var_name!r}.' 

427 ) 

428 private_attributes[var_name] = value 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

429 del namespace[var_name] 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

430 elif isinstance(value, FieldInfo) and not is_valid_field_name(var_name): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

431 suggested_name = var_name.lstrip('_') or 'my_field' # don't suggest '' for all-underscore name 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

432 raise NameError( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

433 f'Fields must not use names with leading underscores;' 

434 f' e.g., use {suggested_name!r} instead of {var_name!r}.' 

435 ) 

436 

437 elif var_name.startswith('__'): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

438 continue 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

439 elif is_valid_privateattr_name(var_name): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

440 if var_name not in raw_annotations or not is_classvar_annotation(raw_annotations[var_name]): 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

441 private_attributes[var_name] = cast(ModelPrivateAttr, PrivateAttr(default=value)) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

442 del namespace[var_name] 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

443 elif var_name in base_class_vars: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

444 continue 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

445 elif var_name not in raw_annotations: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

446 if var_name in base_class_fields: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

447 raise PydanticUserError( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

448 f'Field {var_name!r} defined on a base class was overridden by a non-annotated attribute. ' 

449 f'All field definitions, including overrides, require a type annotation.', 

450 code='model-field-overridden', 

451 ) 

452 elif isinstance(value, FieldInfo): 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

453 raise PydanticUserError( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

454 f'Field {var_name!r} requires a type annotation', code='model-field-missing-annotation' 

455 ) 

456 else: 

457 raise PydanticUserError( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

458 f'A non-annotated attribute was detected: `{var_name} = {value!r}`. All model fields require a ' 

459 f'type annotation; if `{var_name}` is not meant to be a field, you may be able to resolve this ' 

460 f"error by annotating it as a `ClassVar` or updating `model_config['ignored_types']`.", 

461 code='model-field-missing-annotation', 

462 ) 

463 

464 for ann_name, ann_type in raw_annotations.items(): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

465 if ( 23 ctx1adeofpghbijsktJKLclmwnx

466 is_valid_privateattr_name(ann_name) 

467 and ann_name not in private_attributes 

468 and ann_name not in ignored_names 

469 # This condition can be a false negative when `ann_type` is stringified, 

470 # but it is handled in most cases in `set_model_fields`: 

471 and not is_classvar_annotation(ann_type) 

472 and ann_type not in all_ignored_types 

473 and getattr(ann_type, '__module__', None) != 'functools' 

474 ): 

475 if isinstance(ann_type, str): 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

476 # Walking up the frames to get the module namespace where the model is defined 

477 # (as the model class wasn't created yet, we unfortunately can't use `cls.__module__`): 

478 frame = sys._getframe(2) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

479 if frame is not None: 479 ↛ 489line 479 didn't jump to line 489 because the condition on line 479 was always true35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

480 try: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

481 ann_type = eval_type_backport( 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

482 _make_forward_ref(ann_type, is_argument=False, is_class=True), 

483 globalns=frame.f_globals, 

484 localns=frame.f_locals, 

485 ) 

486 except (NameError, TypeError): 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

487 pass 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

488 

489 if typing_objects.is_annotated(get_origin(ann_type)): 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

490 _, *metadata = get_args(ann_type) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

491 private_attr = next((v for v in metadata if isinstance(v, ModelPrivateAttr)), None) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

492 if private_attr is not None: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

493 private_attributes[ann_name] = private_attr 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

494 continue 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

495 private_attributes[ann_name] = PrivateAttr() 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

496 

497 return private_attributes 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

498 

499 

500def set_default_hash_func(cls: type[BaseModel], bases: tuple[type[Any], ...]) -> None: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

501 base_hash_func = get_attribute_from_bases(bases, '__hash__') 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

502 new_hash_func = make_hash_func(cls) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

503 if base_hash_func in {None, object.__hash__} or getattr(base_hash_func, '__code__', None) == new_hash_func.__code__: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

504 # If `__hash__` is some default, we generate a hash function. 

505 # It will be `None` if not overridden from BaseModel. 

506 # It may be `object.__hash__` if there is another 

507 # parent class earlier in the bases which doesn't override `__hash__` (e.g. `typing.Generic`). 

508 # It may be a value set by `set_default_hash_func` if `cls` is a subclass of another frozen model. 

509 # In the last case we still need a new hash function to account for new `model_fields`. 

510 cls.__hash__ = new_hash_func 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

511 

512 

513def make_hash_func(cls: type[BaseModel]) -> Any: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

514 getter = operator.itemgetter(*cls.__pydantic_fields__.keys()) if cls.__pydantic_fields__ else lambda _: 0 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

515 

516 def hash_func(self: Any) -> int: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

517 try: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

518 return hash(getter(self.__dict__)) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

519 except KeyError: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

520 # In rare cases (such as when using the deprecated copy method), the __dict__ may not contain 

521 # all model fields, which is how we can get here. 

522 # getter(self.__dict__) is much faster than any 'safe' method that accounts for missing keys, 

523 # and wrapping it in a `try` doesn't slow things down much in the common case. 

524 return hash(getter(SafeGetItemProxy(self.__dict__))) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

525 

526 return hash_func 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

527 

528 

529def set_model_fields( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

530 cls: type[BaseModel], 

531 config_wrapper: ConfigWrapper, 

532 ns_resolver: NsResolver | None, 

533) -> None: 

534 """Collect and set `cls.__pydantic_fields__` and `cls.__class_vars__`. 

535 

536 Args: 

537 cls: BaseModel or dataclass. 

538 config_wrapper: The config wrapper instance. 

539 ns_resolver: Namespace resolver to use when getting model annotations. 

540 """ 

541 typevars_map = get_model_typevars_map(cls) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

542 fields, class_vars = collect_model_fields(cls, config_wrapper, ns_resolver, typevars_map=typevars_map) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

543 

544 cls.__pydantic_fields__ = fields 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

545 cls.__class_vars__.update(class_vars) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

546 

547 for k in class_vars: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

548 # Class vars should not be private attributes 

549 # We remove them _here_ and not earlier because we rely on inspecting the class to determine its classvars, 

550 # but private attributes are determined by inspecting the namespace _prior_ to class creation. 

551 # In the case that a classvar with a leading-'_' is defined via a ForwardRef (e.g., when using 

552 # `__future__.annotations`), we want to remove the private attribute which was detected _before_ we knew it 

553 # evaluated to a classvar 

554 

555 value = cls.__private_attributes__.pop(k, None) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

556 if value is not None and value.default is not PydanticUndefined: 556 ↛ 557line 556 didn't jump to line 557 because the condition on line 556 was never true42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

557 setattr(cls, k, value.default) 

558 

559 

560def complete_model_class( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

561 cls: type[BaseModel], 

562 config_wrapper: ConfigWrapper, 

563 ns_resolver: NsResolver, 

564 *, 

565 raise_errors: bool = True, 

566 create_model_module: str | None = None, 

567) -> bool: 

568 """Finish building a model class. 

569 

570 This logic must be called after class has been created since validation functions must be bound 

571 and `get_type_hints` requires a class object. 

572 

573 Args: 

574 cls: BaseModel or dataclass. 

575 config_wrapper: The config wrapper instance. 

576 ns_resolver: The namespace resolver instance to use during schema building. 

577 raise_errors: Whether to raise errors. 

578 create_model_module: The module of the class to be created, if created by `create_model`. 

579 

580 Returns: 

581 `True` if the model is successfully completed, else `False`. 

582 

583 Raises: 

584 PydanticUndefinedAnnotation: If `PydanticUndefinedAnnotation` occurs in`__get_pydantic_core_schema__` 

585 and `raise_errors=True`. 

586 """ 

587 typevars_map = get_model_typevars_map(cls) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

588 

589 if not cls.__pydantic_fields_complete__: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

590 # Note: when coming from `ModelMetaclass.__new__()`, this results in fields being built twice. 

591 # We do so a second time here so that we can get the `NameError` for the specific undefined annotation. 

592 # Alternatively, we could let `GenerateSchema()` raise the error, but there are cases where incomplete 

593 # fields are inherited in `collect_model_fields()` and can actually have their annotation resolved in the 

594 # generate schema process. As we want to avoid having `__pydantic_fields_complete__` set to `False` 

595 # when `__pydantic_complete__` is `True`, we rebuild here: 

596 try: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

597 cls.__pydantic_fields__ = rebuild_model_fields( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

598 cls, 

599 config_wrapper=config_wrapper, 

600 ns_resolver=ns_resolver, 

601 typevars_map=typevars_map, 

602 ) 

603 except NameError as e: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

604 exc = PydanticUndefinedAnnotation.from_name_error(e) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

605 set_model_mocks(cls, f'`{exc.name}`') 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

606 if raise_errors: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

607 raise exc from e 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

608 

609 if not raise_errors and not cls.__pydantic_fields_complete__: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

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

611 return False 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

612 

613 assert cls.__pydantic_fields_complete__ 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

614 

615 gen_schema = GenerateSchema( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

616 config_wrapper, 

617 ns_resolver, 

618 typevars_map, 

619 ) 

620 

621 try: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

622 schema = gen_schema.generate_schema(cls) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

623 except PydanticUndefinedAnnotation as e: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

624 if raise_errors: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

625 raise 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

626 set_model_mocks(cls, f'`{e.name}`') 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

627 return False 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

628 

629 core_config = config_wrapper.core_config(title=cls.__name__) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

630 

631 try: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

632 schema = gen_schema.clean_schema(schema) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

633 except InvalidSchemaError: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

634 set_model_mocks(cls) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

635 return False 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

636 

637 # This needs to happen *after* model schema generation, as the return type 

638 # of the properties are evaluated and the `ComputedFieldInfo` are recreated: 

639 cls.__pydantic_computed_fields__ = {k: v.info for k, v in cls.__pydantic_decorators__.computed_fields.items()} 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

640 

641 set_deprecated_descriptors(cls) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

642 

643 cls.__pydantic_core_schema__ = schema 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

644 

645 cls.__pydantic_validator__ = create_schema_validator( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

646 schema, 

647 cls, 

648 create_model_module or cls.__module__, 

649 cls.__qualname__, 

650 'create_model' if create_model_module else 'BaseModel', 

651 core_config, 

652 config_wrapper.plugin_settings, 

653 ) 

654 cls.__pydantic_serializer__ = SchemaSerializer(schema, core_config) 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

655 

656 # set __signature__ attr only for model class, but not for its instances 

657 # (because instances can define `__call__`, and `inspect.signature` shouldn't 

658 # use the `__signature__` attribute and instead generate from `__call__`). 

659 cls.__signature__ = LazyClassAttribute( 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

660 '__signature__', 

661 partial( 

662 generate_pydantic_signature, 

663 init=cls.__init__, 

664 fields=cls.__pydantic_fields__, 

665 validate_by_name=config_wrapper.validate_by_name, 

666 extra=config_wrapper.extra, 

667 ), 

668 ) 

669 

670 cls.__pydantic_complete__ = True 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

671 

672 return True 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

673 

674 

675def set_deprecated_descriptors(cls: type[BaseModel]) -> None: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

676 """Set data descriptors on the class for deprecated fields.""" 

677 for field, field_info in cls.__pydantic_fields__.items(): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

678 if (msg := field_info.deprecation_message) is not None: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

679 desc = _DeprecatedFieldDescriptor(msg) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

680 desc.__set_name__(cls, field) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

681 setattr(cls, field, desc) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

682 

683 for field, computed_field_info in cls.__pydantic_computed_fields__.items(): 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

684 if ( 8 ctx1adghbicl

685 (msg := computed_field_info.deprecation_message) is not None 

686 # Avoid having two warnings emitted: 

687 and not hasattr(unwrap_wrapped_function(computed_field_info.wrapped_property), '__deprecated__') 

688 ): 

689 desc = _DeprecatedFieldDescriptor(msg, computed_field_info.wrapped_property) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

690 desc.__set_name__(cls, field) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

691 setattr(cls, field, desc) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

692 

693 

694class _DeprecatedFieldDescriptor: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

695 """Read-only data descriptor used to emit a runtime deprecation warning before accessing a deprecated field. 

696 

697 Attributes: 

698 msg: The deprecation message to be emitted. 

699 wrapped_property: The property instance if the deprecated field is a computed field, or `None`. 

700 field_name: The name of the field being deprecated. 

701 """ 

702 

703 field_name: str 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

704 

705 def __init__(self, msg: str, wrapped_property: property | None = None) -> None: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

706 self.msg = msg 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

707 self.wrapped_property = wrapped_property 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

708 

709 def __set_name__(self, cls: type[BaseModel], name: str) -> None: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

710 self.field_name = name 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

711 

712 def __get__(self, obj: BaseModel | None, obj_type: type[BaseModel] | None = None) -> Any: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

713 if obj is None: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

714 if self.wrapped_property is not None: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

715 return self.wrapped_property.__get__(None, obj_type) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

716 raise AttributeError(self.field_name) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

717 

718 warnings.warn(self.msg, builtins.DeprecationWarning, stacklevel=2) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

719 

720 if self.wrapped_property is not None: 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

721 return self.wrapped_property.__get__(obj, obj_type) 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

722 return obj.__dict__[self.field_name] 35 ctx1adeofpqArBCghbijsktuDvEFclmwnxyGzHI

723 

724 # Defined to make it a data descriptor and take precedence over the instance's dictionary. 

725 # Note that it will not be called when setting a value on a model instance 

726 # as `BaseModel.__setattr__` is defined and takes priority. 

727 def __set__(self, obj: Any, value: Any) -> NoReturn: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

728 raise AttributeError(self.field_name) 

729 

730 

731class _PydanticWeakRef: 42 ctx1adeofpqArBCghbijsktuDvEFJKLMNOPclmwnxyGzHI

732 """Wrapper for `weakref.ref` that enables `pickle` serialization. 

733 

734 Cloudpickle fails to serialize `weakref.ref` objects due to an arcane error related 

735 to abstract base classes (`abc.ABC`). This class works around the issue by wrapping 

736 `weakref.ref` instead of subclassing it. 

737 

738 See https://github.com/pydantic/pydantic/issues/6763 for context. 

739 

740 Semantics: 

741 - If not pickled, behaves the same as a `weakref.ref`. 

742 - If pickled along with the referenced object, the same `weakref.ref` behavior