Coverage for pydantic/mypy.py: 90.97%

1"""This module includes classes and functions designed specifically for use with the mypy plugin.""" 

2 

3from __future__ import annotations 47 ctx1klmnopqrstuvwxyzABCDEFGHIghfbcaijdeJKLMNOPQRSTU

4 

5import sys 47 ctx1klmnopqrstuvwxyzABCDEFGHIghfbcaijdeJKLMNOPQRSTU

6from configparser import ConfigParser 47 ctx1klmnopqrstuvwxyzABCDEFGHIghfbcaijdeJKLMNOPQRSTU

7from typing import Any, Callable, Iterator 47 ctx1klmnopqrstuvwxyzABCDEFGHIghfbcaijdeJKLMNOPQRSTU

8 

9from mypy.errorcodes import ErrorCode 47 ctx1klmnopqrstuvwxyzABCDEFGHIghfbcaijdeJKLMNOPQRSTU

10from mypy.expandtype import expand_type, expand_type_by_instance 10 ctx1ghfbcaijde

11from mypy.nodes import ( 10 ctx1ghfbcaijde

12 ARG_NAMED, 

13 ARG_NAMED_OPT, 

14 ARG_OPT, 

15 ARG_POS, 

16 ARG_STAR2, 

17 INVARIANT, 

18 MDEF, 

19 Argument, 

20 AssignmentStmt, 

21 Block, 

22 CallExpr, 

23 ClassDef, 

24 Context, 

25 Decorator, 

26 DictExpr, 

27 EllipsisExpr, 

28 Expression, 

29 FuncDef, 

30 IfStmt, 

31 JsonDict, 

32 MemberExpr, 

33 NameExpr, 

34 PassStmt, 

35 PlaceholderNode, 

36 RefExpr, 

37 Statement, 

38 StrExpr, 

39 SymbolTableNode, 

40 TempNode, 

41 TypeAlias, 

42 TypeInfo, 

43 Var, 

44) 

45from mypy.options import Options 10 ctx1ghfbcaijde

46from mypy.plugin import ( 10 ctx1ghfbcaijde

47 CheckerPluginInterface, 

48 ClassDefContext, 

49 FunctionContext, 

50 MethodContext, 

51 Plugin, 

52 ReportConfigContext, 

53 SemanticAnalyzerPluginInterface, 

54) 

55from mypy.plugins import dataclasses 10 ctx1ghfbcaijde

56from mypy.plugins.common import ( 10 ctx1ghfbcaijde

57 deserialize_and_fixup_type, 

58) 

59from mypy.semanal import set_callable_name 10 ctx1ghfbcaijde

60from mypy.server.trigger import make_wildcard_trigger 10 ctx1ghfbcaijde

61from mypy.state import state 10 ctx1ghfbcaijde

62from mypy.typeops import map_type_from_supertype 10 ctx1ghfbcaijde

63from mypy.types import ( 10 ctx1ghfbcaijde

64 AnyType, 

65 CallableType, 

66 Instance, 

67 NoneType, 

68 Overloaded, 

69 Type, 

70 TypeOfAny, 

71 TypeType, 

72 TypeVarType, 

73 UnionType, 

74 get_proper_type, 

75) 

76from mypy.typevars import fill_typevars 10 ctx1ghfbcaijde

77from mypy.util import get_unique_redefinition_name 10 ctx1ghfbcaijde

78from mypy.version import __version__ as mypy_version 10 ctx1ghfbcaijde

79 

80from pydantic._internal import _fields 10 ctx1ghfbcaijde

81from pydantic.version import parse_mypy_version 10 ctx1ghfbcaijde

82 

83try: 10 ctx1ghfbcaijde

84 from mypy.types import TypeVarDef # type: ignore[attr-defined] 10 ctx1ghfbcaijde

85except ImportError: # pragma: no cover 10 ctx1ghfbcaijde

86 # Backward-compatible with TypeVarDef from Mypy 0.930. 

87 from mypy.types import TypeVarType as TypeVarDef 10 ctx1ghfbcaijde

88 

89CONFIGFILE_KEY = 'pydantic-mypy' 10 ctx1ghfbcaijde

90METADATA_KEY = 'pydantic-mypy-metadata' 10 ctx1ghfbcaijde

91BASEMODEL_FULLNAME = 'pydantic.main.BaseModel' 10 ctx1ghfbcaijde

92BASESETTINGS_FULLNAME = 'pydantic_settings.main.BaseSettings' 10 ctx1ghfbcaijde

93ROOT_MODEL_FULLNAME = 'pydantic.root_model.RootModel' 10 ctx1ghfbcaijde

94MODEL_METACLASS_FULLNAME = 'pydantic._internal._model_construction.ModelMetaclass' 10 ctx1ghfbcaijde

95FIELD_FULLNAME = 'pydantic.fields.Field' 10 ctx1ghfbcaijde

96DATACLASS_FULLNAME = 'pydantic.dataclasses.dataclass' 10 ctx1ghfbcaijde

97MODEL_VALIDATOR_FULLNAME = 'pydantic.functional_validators.model_validator' 10 ctx1ghfbcaijde

98DECORATOR_FULLNAMES = { 10 ctx1ghfbcaijde

99 'pydantic.functional_validators.field_validator', 

100 'pydantic.functional_validators.model_validator', 

101 'pydantic.functional_serializers.serializer', 

102 'pydantic.functional_serializers.model_serializer', 

103 'pydantic.deprecated.class_validators.validator', 

104 'pydantic.deprecated.class_validators.root_validator', 

105} 

106 

107 

108MYPY_VERSION_TUPLE = parse_mypy_version(mypy_version) 10 ctx1ghfbcaijde

109BUILTINS_NAME = 'builtins' if MYPY_VERSION_TUPLE >= (0, 930) else '__builtins__' 10 ctx1ghfbcaijde

110 

111# Increment version if plugin changes and mypy caches should be invalidated 

112__version__ = 2 10 ctx1ghfbcaijde

113 

114 

115def plugin(version: str) -> type[Plugin]: 10 ctx1ghfbcaijde

116 """`version` is the mypy version string. 

117 

118 We might want to use this to print a warning if the mypy version being used is 

119 newer, or especially older, than we expect (or need). 

120 

121 Args: 

122 version: The mypy version string. 

123 

124 Return: 

125 The Pydantic mypy plugin type. 

126 """ 

127 return PydanticPlugin 10 ctx1ghfbcaijde

128 

129 

130class PydanticPlugin(Plugin): 10 ctx1ghfbcaijde

131 """The Pydantic mypy plugin.""" 

132 

133 def __init__(self, options: Options) -> None: 10 ctx1ghfbcaijde

134 self.plugin_config = PydanticPluginConfig(options) 10 ctx1ghfbcaijde

135 self._plugin_data = self.plugin_config.to_data() 10 ctx1ghfbcaijde

136 super().__init__(options) 10 ctx1ghfbcaijde

137 

138 def get_base_class_hook(self, fullname: str) -> Callable[[ClassDefContext], bool] | None: 10 ctx1ghfbcaijde

139 """Update Pydantic model class.""" 

140 sym = self.lookup_fully_qualified(fullname) 10 ctx1ghfbcaijde

141 if sym and isinstance(sym.node, TypeInfo): # pragma: no branch 10 ctx1ghfbcaijde

142 # No branching may occur if the mypy cache has not been cleared 

143 if any(base.fullname == BASEMODEL_FULLNAME for base in sym.node.mro): 10 ctx1ghfbcaijde

144 return self._pydantic_model_class_maker_callback 10 ctx1ghfbcaijde

145 return None 10 ctx1ghfbcaijde

146 

147 def get_metaclass_hook(self, fullname: str) -> Callable[[ClassDefContext], None] | None: 10 ctx1ghfbcaijde

148 """Update Pydantic `ModelMetaclass` definition.""" 

149 if fullname == MODEL_METACLASS_FULLNAME: 10 ctx1ghfbcaijde

150 return self._pydantic_model_metaclass_marker_callback 10 ctx1ghfbcaijde

151 return None 10 ctx1ghfbcaijde

152 

153 def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None: 10 ctx1ghfbcaijde

154 """Adjust the return type of the `Field` function.""" 

155 sym = self.lookup_fully_qualified(fullname) 10 ctx1ghfbcaijde

156 if sym and sym.fullname == FIELD_FULLNAME: 10 ctx1ghfbcaijde

157 return self._pydantic_field_callback 10 ctx1ghfbcaijde

158 return None 10 ctx1ghfbcaijde

159 

160 def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | None: 10 ctx1ghfbcaijde

161 """Adjust return type of `from_orm` method call.""" 

162 if fullname.endswith('.from_orm'): 10 ctx1ghfbcaijde

163 return from_attributes_callback 10 ctx1ghfbcaijde

164 return None 10 ctx1ghfbcaijde

165 

166 def get_class_decorator_hook(self, fullname: str) -> Callable[[ClassDefContext], None] | None: 10 ctx1ghfbcaijde

167 """Mark pydantic.dataclasses as dataclass. 

168 

169 Mypy version 1.1.1 added support for `@dataclass_transform` decorator. 

170 """ 

171 if fullname == DATACLASS_FULLNAME and MYPY_VERSION_TUPLE < (1, 1): 10 ctx1ghfbcaijde

172 return dataclasses.dataclass_class_maker_callback # type: ignore[return-value] 1 ctx1f

173 return None 10 ctx1ghfbcaijde

174 

175 def report_config_data(self, ctx: ReportConfigContext) -> dict[str, Any]: 10 ctx1ghfbcaijde

176 """Return all plugin config data. 

177 

178 Used by mypy to determine if cache needs to be discarded. 

179 """ 

180 return self._plugin_data 10 ctx1ghfbcaijde

181 

182 def _pydantic_model_class_maker_callback(self, ctx: ClassDefContext) -> bool: 10 ctx1ghfbcaijde

183 transformer = PydanticModelTransformer(ctx.cls, ctx.reason, ctx.api, self.plugin_config) 10 ctx1ghfbcaijde

184 return transformer.transform() 10 ctx1ghfbcaijde

185 

186 def _pydantic_model_metaclass_marker_callback(self, ctx: ClassDefContext) -> None: 10 ctx1ghfbcaijde

187 """Reset dataclass_transform_spec attribute of ModelMetaclass. 

188 

189 Let the plugin handle it. This behavior can be disabled 

190 if 'debug_dataclass_transform' is set to True', for testing purposes. 

191 """ 

192 if self.plugin_config.debug_dataclass_transform: 192 ↛ 193line 192 didn't jump to line 193 because the condition on line 192 was never true10 ctx1ghfbcaijde

193 return 

194 info_metaclass = ctx.cls.info.declared_metaclass 10 ctx1ghfbcaijde

195 assert info_metaclass, "callback not passed from 'get_metaclass_hook'" 10 ctx1ghfbcaijde

196 if getattr(info_metaclass.type, 'dataclass_transform_spec', None): 10 ctx1ghfbcaijde

197 info_metaclass.type.dataclass_transform_spec = None 9 ctx1ghbcaijde

198 

199 def _pydantic_field_callback(self, ctx: FunctionContext) -> Type: 10 ctx1ghfbcaijde

200 """Extract the type of the `default` argument from the Field function, and use it as the return type. 

201 

202 In particular: 

203 * Check whether the default and default_factory argument is specified. 

204 * Output an error if both are specified. 

205 * Retrieve the type of the argument which is specified, and use it as return type for the function. 

206 """ 

207 default_any_type = ctx.default_return_type 10 ctx1ghfbcaijde

208 

209 assert ctx.callee_arg_names[0] == 'default', '"default" is no longer first argument in Field()' 10 ctx1ghfbcaijde

210 assert ctx.callee_arg_names[1] == 'default_factory', '"default_factory" is no longer second argument in Field()' 10 ctx1ghfbcaijde

211 default_args = ctx.args[0] 10 ctx1ghfbcaijde

212 default_factory_args = ctx.args[1] 10 ctx1ghfbcaijde

213 

214 if default_args and default_factory_args: 10 ctx1ghfbcaijde

215 error_default_and_default_factory_specified(ctx.api, ctx.context) 10 ctx1ghfbcaijde

216 return default_any_type 10 ctx1ghfbcaijde

217 

218 if default_args: 10 ctx1ghfbcaijde

219 default_type = ctx.arg_types[0][0] 10 ctx1ghfbcaijde

220 default_arg = default_args[0] 10 ctx1ghfbcaijde

221 

222 # Fallback to default Any type if the field is required 

223 if not isinstance(default_arg, EllipsisExpr): 10 ctx1ghfbcaijde

224 return default_type 10 ctx1ghfbcaijde

225 

226 elif default_factory_args: 10 ctx1ghfbcaijde

227 default_factory_type = ctx.arg_types[1][0] 10 ctx1ghfbcaijde

228 

229 # Functions which use `ParamSpec` can be overloaded, exposing the callable's types as a parameter 

230 # Pydantic calls the default factory without any argument, so we retrieve the first item 

231 if isinstance(default_factory_type, Overloaded): 10 ctx1ghfbcaijde

232 default_factory_type = default_factory_type.items[0] 10 ctx1ghfbcaijde

233 

234 if isinstance(default_factory_type, CallableType): 10 ctx1ghfbcaijde

235 ret_type = default_factory_type.ret_type 10 ctx1ghfbcaijde

236 # mypy doesn't think `ret_type` has `args`, you'd think mypy should know, 

237 # add this check in case it varies by version 

238 args = getattr(ret_type, 'args', None) 10 ctx1ghfbcaijde

239 if args: 10 ctx1ghfbcaijde

240 if all(isinstance(arg, TypeVarType) for arg in args): 10 ctx1ghfbcaijde

241 # Looks like the default factory is a type like `list` or `dict`, replace all args with `Any` 

242 ret_type.args = tuple(default_any_type for _ in args) # type: ignore[attr-defined] 10 ctx1ghfbcaijde

243 return ret_type 10 ctx1ghfbcaijde

244 

245 return default_any_type 10 ctx1ghfbcaijde

246 

247 

248class PydanticPluginConfig: 10 ctx1ghfbcaijde

249 """A Pydantic mypy plugin config holder. 

250 

251 Attributes: 

252 init_forbid_extra: Whether to add a `**kwargs` at the end of the generated `__init__` signature. 

253 init_typed: Whether to annotate fields in the generated `__init__`. 

254 warn_required_dynamic_aliases: Whether to raise required dynamic aliases error. 

255 debug_dataclass_transform: Whether to not reset `dataclass_transform_spec` attribute 

256 of `ModelMetaclass` for testing purposes. 

257 """ 

258 

259 __slots__ = ( 10 ctx1ghfbcaijde

260 'init_forbid_extra', 

261 'init_typed', 

262 'warn_required_dynamic_aliases', 

263 'debug_dataclass_transform', 

264 ) 

265 init_forbid_extra: bool 10 ctx1ghfbcaijde

266 init_typed: bool 10 ctx1ghfbcaijde

267 warn_required_dynamic_aliases: bool 10 ctx1ghfbcaijde

268 debug_dataclass_transform: bool # undocumented 10 ctx1ghfbcaijde

269 

270 def __init__(self, options: Options) -> None: 10 ctx1ghfbcaijde

271 if options.config_file is None: # pragma: no cover 10 ctx1ghfbcaijde

272 return 

273 

274 toml_config = parse_toml(options.config_file) 10 ctx1ghfbcaijde

275 if toml_config is not None: 10 ctx1ghfbcaijde

276 config = toml_config.get('tool', {}).get('pydantic-mypy', {}) 10 ctx1ghfbcaijde

277 for key in self.__slots__: 10 ctx1ghfbcaijde

278 setting = config.get(key, False) 10 ctx1ghfbcaijde

279 if not isinstance(setting, bool): 10 ctx1ghfbcaijde

280 raise ValueError(f'Configuration value must be a boolean for key: {key}') 10 ctx1ghfbcaijde

281 setattr(self, key, setting) 10 ctx1ghfbcaijde

282 else: 

283 plugin_config = ConfigParser() 10 ctx1ghfbcaijde

284 plugin_config.read(options.config_file) 10 ctx1ghfbcaijde

285 for key in self.__slots__: 10 ctx1ghfbcaijde

286 setting = plugin_config.getboolean(CONFIGFILE_KEY, key, fallback=False) 10 ctx1ghfbcaijde

287 setattr(self, key, setting) 10 ctx1ghfbcaijde

288 

289 def to_data(self) -> dict[str, Any]: 10 ctx1ghfbcaijde

290 """Returns a dict of config names to their values.""" 

291 return {key: getattr(self, key) for key in self.__slots__} 10 ctx1ghfbcaijde

292 

293 

294def from_attributes_callback(ctx: MethodContext) -> Type: 10 ctx1ghfbcaijde

295 """Raise an error if from_attributes is not enabled.""" 

296 model_type: Instance 

297 ctx_type = ctx.type 10 ctx1ghfbcaijde

298 if isinstance(ctx_type, TypeType): 10 ctx1ghfbcaijde

299 ctx_type = ctx_type.item 10 ctx1ghfbcaijde

300 if isinstance(ctx_type, CallableType) and isinstance(ctx_type.ret_type, Instance): 10 ctx1ghfbcaijde

301 model_type = ctx_type.ret_type # called on the class 5 ctx1bcade

302 elif isinstance(ctx_type, Instance): 10 ctx1ghfbcaijde

303 model_type = ctx_type # called on an instance (unusual, but still valid) 10 ctx1ghfbcaijde

304 else: # pragma: no cover 

305 detail = f'ctx.type: {ctx_type} (of type {ctx_type.__class__.__name__})' 

306 error_unexpected_behavior(detail, ctx.api, ctx.context) 

307 return ctx.default_return_type 

308 pydantic_metadata = model_type.type.metadata.get(METADATA_KEY) 10 ctx1ghfbcaijde

309 if pydantic_metadata is None: 10 ctx1ghfbcaijde

310 return ctx.default_return_type 10 ctx1ghfbcaijde

311 from_attributes = pydantic_metadata.get('config', {}).get('from_attributes') 5 ctx1bcade

312 if from_attributes is not True: 312 ↛ 314line 312 didn't jump to line 314 because the condition on line 312 was always true5 ctx1bcade

313 error_from_attributes(model_type.type.name, ctx.api, ctx.context) 5 ctx1bcade

314 return ctx.default_return_type 5 ctx1bcade

315 

316 

317class PydanticModelField: 10 ctx1ghfbcaijde

318 """Based on mypy.plugins.dataclasses.DataclassAttribute.""" 

319 

320 def __init__( 10 ctx1ghfbcaijde

321 self, 

322 name: str, 

323 alias: str | None, 

324 has_dynamic_alias: bool, 

325 has_default: bool, 

326 line: int, 

327 column: int, 

328 type: Type | None, 

329 info: TypeInfo, 

330 ): 

331 self.name = name 10 ctx1ghfbcaijde

332 self.alias = alias 10 ctx1ghfbcaijde

333 self.has_dynamic_alias = has_dynamic_alias 10 ctx1ghfbcaijde

334 self.has_default = has_default 10 ctx1ghfbcaijde

335 self.line = line 10 ctx1ghfbcaijde

336 self.column = column 10 ctx1ghfbcaijde

337 self.type = type 10 ctx1ghfbcaijde

338 self.info = info 10 ctx1ghfbcaijde

339 

340 def to_argument( 10 ctx1ghfbcaijde

341 self, 

342 current_info: TypeInfo, 

343 typed: bool, 

344 force_optional: bool, 

345 use_alias: bool, 

346 api: SemanticAnalyzerPluginInterface, 

347 force_typevars_invariant: bool, 

348 ) -> Argument: 

349 """Based on mypy.plugins.dataclasses.DataclassAttribute.to_argument.""" 

350 variable = self.to_var(current_info, api, use_alias, force_typevars_invariant) 10 ctx1ghfbcaijde

351 type_annotation = self.expand_type(current_info, api) if typed else AnyType(TypeOfAny.explicit) 10 ctx1ghfbcaijde

352 return Argument( 10 ctx1ghfbcaijde

353 variable=variable, 

354 type_annotation=type_annotation, 

355 initializer=None, 

356 kind=ARG_NAMED_OPT if force_optional or self.has_default else ARG_NAMED, 

357 ) 

358 

359 def expand_type( 10 ctx1ghfbcaijde

360 self, current_info: TypeInfo, api: SemanticAnalyzerPluginInterface, force_typevars_invariant: bool = False 

361 ) -> Type | None: 

362 """Based on mypy.plugins.dataclasses.DataclassAttribute.expand_type.""" 

363 # The getattr in the next line is used to prevent errors in legacy versions of mypy without this attribute 

364 if force_typevars_invariant: 10 ctx1ghfbcaijde

365 # In some cases, mypy will emit an error "Cannot use a covariant type variable as a parameter" 

366 # To prevent that, we add an option to replace typevars with invariant ones while building certain 

367 # method signatures (in particular, `__init__`). There may be a better way to do this, if this causes 

368 # us problems in the future, we should look into why the dataclasses plugin doesn't have this issue. 

369 if isinstance(self.type, TypeVarType): 10 ctx1ghfbcaijde

370 modified_type = self.type.copy_modified() 10 ctx1ghfbcaijde

371 modified_type.variance = INVARIANT 10 ctx1ghfbcaijde

372 self.type = modified_type 10 ctx1ghfbcaijde

373 

374 if self.type is not None and getattr(self.info, 'self_type', None) is not None: 10 ctx1ghfbcaijde

375 # In general, it is not safe to call `expand_type()` during semantic analyzis, 

376 # however this plugin is called very late, so all types should be fully ready. 

377 # Also, it is tricky to avoid eager expansion of Self types here (e.g. because 

378 # we serialize attributes). 

379 with state.strict_optional_set(api.options.strict_optional): 10 ctx1ghfbcaijde

380 filled_with_typevars = fill_typevars(current_info) 10 ctx1ghfbcaijde

381 if force_typevars_invariant: 10 ctx1ghfbcaijde

382 for arg in filled_with_typevars.args: 10 ctx1ghfbcaijde

383 if isinstance(arg, TypeVarType): 383 ↛ 382line 383 didn't jump to line 382 because the condition on line 383 was always true3 ctx1ade

384 arg.variance = INVARIANT 3 ctx1ade

385 return expand_type(self.type, {self.info.self_type.id: filled_with_typevars}) 10 ctx1ghfbcaijde

386 return self.type 7 ctx1ghfbcij

387 

388 def to_var( 10 ctx1ghfbcaijde

389 self, 

390 current_info: TypeInfo, 

391 api: SemanticAnalyzerPluginInterface, 

392 use_alias: bool, 

393 force_typevars_invariant: bool = False, 

394 ) -> Var: 

395 """Based on mypy.plugins.dataclasses.DataclassAttribute.to_var.""" 

396 if use_alias and self.alias is not None: 10 ctx1ghfbcaijde

397 name = self.alias 10 ctx1ghfbcaijde

398 else: 

399 name = self.name 10 ctx1ghfbcaijde

400 

401 return Var(name, self.expand_type(current_info, api, force_typevars_invariant)) 10 ctx1ghfbcaijde

402 

403 def serialize(self) -> JsonDict: 10 ctx1ghfbcaijde

404 """Based on mypy.plugins.dataclasses.DataclassAttribute.serialize.""" 

405 assert self.type 10 ctx1ghfbcaijde

406 return { 10 ctx1ghfbcaijde

407 'name': self.name, 

408 'alias': self.alias, 

409 'has_dynamic_alias': self.has_dynamic_alias, 

410 'has_default': self.has_default, 

411 'line': self.line, 

412 'column': self.column, 

413 'type': self.type.serialize(), 

414 } 

415 

416 @classmethod 10 ctx1ghfbcaijde

417 def deserialize(cls, info: TypeInfo, data: JsonDict, api: SemanticAnalyzerPluginInterface) -> PydanticModelField: 10 ctx1ghfbcaijde

418 """Based on mypy.plugins.dataclasses.DataclassAttribute.deserialize.""" 

419 data = data.copy() 10 ctx1ghfbcaijde

420 typ = deserialize_and_fixup_type(data.pop('type'), api) 10 ctx1ghfbcaijde

421 return cls(type=typ, info=info, **data) 10 ctx1ghfbcaijde

422 

423 def expand_typevar_from_subtype(self, sub_type: TypeInfo, api: SemanticAnalyzerPluginInterface) -> None: 10 ctx1ghfbcaijde

424 """Expands type vars in the context of a subtype when an attribute is inherited 

425 from a generic super type. 

426 """ 

427 if self.type is not None: 427 ↛ exitline 427 didn't return from function 'expand_typevar_from_subtype' because the condition on line 427 was always true10 ctx1ghfbcaijde

428 with state.strict_optional_set(api.options.strict_optional): 10 ctx1ghfbcaijde

429 self.type = map_type_from_supertype(self.type, sub_type, self.info) 10 ctx1ghfbcaijde

430 

431 

432class PydanticModelClassVar: 10 ctx1ghfbcaijde

433 """Based on mypy.plugins.dataclasses.DataclassAttribute. 

434 

435 ClassVars are ignored by subclasses. 

436 

437 Attributes: 

438 name: the ClassVar name 

439 """ 

440 

441 def __init__(self, name): 10 ctx1ghfbcaijde

442 self.name = name 10 ctx1ghfbcaijde

443 

444 @classmethod 10 ctx1ghfbcaijde

445 def deserialize(cls, data: JsonDict) -> PydanticModelClassVar: 10 ctx1ghfbcaijde

446 """Based on mypy.plugins.dataclasses.DataclassAttribute.deserialize.""" 

447 data = data.copy() 

448 return cls(**data) 

449 

450 def serialize(self) -> JsonDict: 10 ctx1ghfbcaijde

451 """Based on mypy.plugins.dataclasses.DataclassAttribute.serialize.""" 

452 return { 10 ctx1ghfbcaijde

453 'name': self.name, 

454 } 

455 

456 

457class PydanticModelTransformer: 10 ctx1ghfbcaijde

458 """Transform the BaseModel subclass according to the plugin settings. 

459 

460 Attributes: 

461 tracked_config_fields: A set of field configs that the plugin has to track their value. 

462 """ 

463 

464 tracked_config_fields: set[str] = { 10 ctx1ghfbcaijde

465 'extra', 

466 'frozen', 

467 'from_attributes', 

468 'populate_by_name', 

469 'alias_generator', 

470 } 

471 

472 def __init__( 10 ctx1ghfbcaijde

473 self, 

474 cls: ClassDef, 

475 reason: Expression | Statement, 

476 api: SemanticAnalyzerPluginInterface, 

477 plugin_config: PydanticPluginConfig, 

478 ) -> None: 

479 self._cls = cls 10 ctx1ghfbcaijde

480 self._reason = reason 10 ctx1ghfbcaijde

481 self._api = api 10 ctx1ghfbcaijde

482 

483 self.plugin_config = plugin_config 10 ctx1ghfbcaijde

484 

485 def transform(self) -> bool: 10 ctx1ghfbcaijde

486 """Configures the BaseModel subclass according to the plugin settings. 

487 

488 In particular: 

489 

490 * determines the model config and fields, 

491 * adds a fields-aware signature for the initializer and construct methods 

492 * freezes the class if frozen = True 

493 * stores the fields, config, and if the class is settings in the mypy metadata for access by subclasses 

494 """ 

495 info = self._cls.info 10 ctx1ghfbcaijde

496 is_root_model = any(ROOT_MODEL_FULLNAME in base.fullname for base in info.mro[:-1]) 10 ctx1ghfbcaijde

497 config = self.collect_config() 10 ctx1ghfbcaijde

498 fields, class_vars = self.collect_fields_and_class_vars(config, is_root_model) 10 ctx1ghfbcaijde

499 if fields is None or class_vars is None: 499 ↛ 501line 499 didn't jump to line 501 because the condition on line 499 was never true10 ctx1ghfbcaijde

500 # Some definitions are not ready. We need another pass. 

501 return False 

502 for field in fields: 10 ctx1ghfbcaijde

503 if field.type is None: 10 ctx1ghfbcaijde

504 return False 10 ctx1ghfbcaijde

505 

506 is_settings = any(base.fullname == BASESETTINGS_FULLNAME for base in info.mro[:-1]) 10 ctx1ghfbcaijde

507 self.add_initializer(fields, config, is_settings, is_root_model) 10 ctx1ghfbcaijde

508 if not is_root_model: 10 ctx1ghfbcaijde

509 self.add_model_construct_method(fields, config, is_settings) 10 ctx1ghfbcaijde

510 self.set_frozen(fields, self._api, frozen=config.frozen is True) 10 ctx1ghfbcaijde

511 

512 self.adjust_decorator_signatures() 10 ctx1ghfbcaijde

513 

514 info.metadata[METADATA_KEY] = { 10 ctx1ghfbcaijde

515 'fields': {field.name: field.serialize() for field in fields}, 

516 'class_vars': {class_var.name: class_var.serialize() for class_var in class_vars}, 

517 'config': config.get_values_dict(), 

518 } 

519 

520 return True 10 ctx1ghfbcaijde

521 

522 def adjust_decorator_signatures(self) -> None: 10 ctx1ghfbcaijde

523 """When we decorate a function `f` with `pydantic.validator(...)`, `pydantic.field_validator` 

524 or `pydantic.serializer(...)`, mypy sees `f` as a regular method taking a `self` instance, 

525 even though pydantic internally wraps `f` with `classmethod` if necessary. 

526 

527 Teach mypy this by marking any function whose outermost decorator is a `validator()`, 

528 `field_validator()` or `serializer()` call as a `classmethod`. 

529 """ 

530 for name, sym in self._cls.info.names.items(): 10 ctx1ghfbcaijde

531 if isinstance(sym.node, Decorator): 10 ctx1ghfbcaijde

532 first_dec = sym.node.original_decorators[0] 10 ctx1ghfbcaijde

533 if ( 8 ctx1ghfbcaij

534 isinstance(first_dec, CallExpr) 

535 and isinstance(first_dec.callee, NameExpr) 

536 and first_dec.callee.fullname in DECORATOR_FULLNAMES 

537 # @model_validator(mode="after") is an exception, it expects a regular method 

538 and not ( 

539 first_dec.callee.fullname == MODEL_VALIDATOR_FULLNAME 

540 and any( 

541 first_dec.arg_names[i] == 'mode' and isinstance(arg, StrExpr) and arg.value == 'after' 

542 for i, arg in enumerate(first_dec.args) 

543 ) 

544 ) 

545 ): 

546 # TODO: Only do this if the first argument of the decorated function is `cls` 

547 sym.node.func.is_class = True 10 ctx1ghfbcaijde

548 

549 def collect_config(self) -> ModelConfigData: # noqa: C901 (ignore complexity) 10 ctx1ghfbcaijde

550 """Collects the values of the config attributes that are used by the plugin, accounting for parent classes.""" 

551 cls = self._cls 10 ctx1ghfbcaijde

552 config = ModelConfigData() 10 ctx1ghfbcaijde

553 

554 has_config_kwargs = False 10 ctx1ghfbcaijde

555 has_config_from_namespace = False 10 ctx1ghfbcaijde

556 

557 # Handle `class MyModel(BaseModel, <name>=<expr>, ...):` 

558 for name, expr in cls.keywords.items(): 10 ctx1ghfbcaijde

559 config_data = self.get_config_update(name, expr) 10 ctx1ghfbcaijde

560 if config_data: 10 ctx1ghfbcaijde

561 has_config_kwargs = True 10 ctx1ghfbcaijde

562 config.update(config_data) 10 ctx1ghfbcaijde

563 

564 # Handle `model_config` 

565 stmt: Statement | None = None 10 ctx1ghfbcaijde

566 for stmt in cls.defs.body: 10 ctx1ghfbcaijde

567 if not isinstance(stmt, (AssignmentStmt, ClassDef)): 10 ctx1ghfbcaijde

568 continue 10 ctx1ghfbcaijde

569 

570 if isinstance(stmt, AssignmentStmt): 10 ctx1ghfbcaijde

571 lhs = stmt.lvalues[0] 10 ctx1ghfbcaijde

572 if not isinstance(lhs, NameExpr) or lhs.name != 'model_config': 10 ctx1ghfbcaijde

573 continue 10 ctx1ghfbcaijde

574 

575 if isinstance(stmt.rvalue, CallExpr): # calls to `dict` or `ConfigDict` 575 ↛ 580line 575 didn't jump to line 580 because the condition on line 575 was always true10 ctx1ghfbcaijde

576 for arg_name, arg in zip(stmt.rvalue.arg_names, stmt.rvalue.args): 10 ctx1ghfbcaijde

577 if arg_name is None: 577 ↛ 578line 577 didn't jump to line 578 because the condition on line 577 was never true10 ctx1ghfbcaijde

578 continue 

579 config.update(self.get_config_update(arg_name, arg, lax_extra=True)) 10 ctx1ghfbcaijde

580 elif isinstance(stmt.rvalue, DictExpr): # dict literals 

581 for key_expr, value_expr in stmt.rvalue.items: 

582 if not isinstance(key_expr, StrExpr): 

583 continue 

584 config.update(self.get_config_update(key_expr.value, value_expr)) 

585 

586 elif isinstance(stmt, ClassDef): 586 ↛ 597line 586 didn't jump to line 597 because the condition on line 586 was always true10 ctx1ghfbcaijde

587 if stmt.name != 'Config': # 'deprecated' Config-class 10 ctx1ghfbcaijde

588 continue 10 ctx1ghfbcaijde

589 for substmt in stmt.defs.body: 10 ctx1ghfbcaijde

590 if not isinstance(substmt, AssignmentStmt): 10 ctx1ghfbcaijde

591 continue 10 ctx1ghfbcaijde

592 lhs = substmt.lvalues[0] 10 ctx1ghfbcaijde

593 if not isinstance(lhs, NameExpr): 593 ↛ 594line 593 didn't jump to line 594 because the condition on line 593 was never true10 ctx1ghfbcaijde

594 continue 

595 config.update(self.get_config_update(lhs.name, substmt.rvalue)) 10 ctx1ghfbcaijde

596 

597 if has_config_kwargs: 597 ↛ 598line 597 didn't jump to line 598 because the condition on line 597 was never true10 ctx1ghfbcaijde

598 self._api.fail( 

599 'Specifying config in two places is ambiguous, use either Config attribute or class kwargs', 

600 cls, 

601 ) 

602 break 

603 

604 has_config_from_namespace = True 10 ctx1ghfbcaijde

605 

606 if has_config_kwargs or has_config_from_namespace: 10 ctx1ghfbcaijde

607 if ( 8 ctx1ghfbcaij

608 stmt 

609 and config.has_alias_generator 

610 and not config.populate_by_name 

611 and self.plugin_config.warn_required_dynamic_aliases 

612 ): 

613 error_required_dynamic_aliases(self._api, stmt) 10 ctx1ghfbcaijde

614 

615 for info in cls.info.mro[1:]: # 0 is the current class 10 ctx1ghfbcaijde

616 if METADATA_KEY not in info.metadata: 10 ctx1ghfbcaijde

617 continue 10 ctx1ghfbcaijde

618 

619 # Each class depends on the set of fields in its ancestors 

620 self._api.add_plugin_dependency(make_wildcard_trigger(info.fullname)) 10 ctx1ghfbcaijde

621 for name, value in info.metadata[METADATA_KEY]['config'].items(): 10 ctx1ghfbcaijde

622 config.setdefault(name, value) 10 ctx1ghfbcaijde

623 return config 10 ctx1ghfbcaijde

624 

625 def collect_fields_and_class_vars( 10 ctx1ghfbcaijde

626 self, model_config: ModelConfigData, is_root_model: bool 

627 ) -> tuple[list[PydanticModelField] | None, list[PydanticModelClassVar] | None]: 

628 """Collects the fields for the model, accounting for parent classes.""" 

629 cls = self._cls 10 ctx1ghfbcaijde

630 

631 # First, collect fields and ClassVars belonging to any class in the MRO, ignoring duplicates. 

632 # 

633 # We iterate through the MRO in reverse because attrs defined in the parent must appear 

634 # earlier in the attributes list than attrs defined in the child. See: 

635 # https://docs.python.org/3/library/dataclasses.html#inheritance 

636 # 

637 # However, we also want fields defined in the subtype to override ones defined 

638 # in the parent. We can implement this via a dict without disrupting the attr order 

639 # because dicts preserve insertion order in Python 3.7+. 

640 found_fields: dict[str, PydanticModelField] = {} 10 ctx1ghfbcaijde

641 found_class_vars: dict[str, PydanticModelClassVar] = {} 10 ctx1ghfbcaijde

642 for info in reversed(cls.info.mro[1:-1]): # 0 is the current class, -2 is BaseModel, -1 is object 10 ctx1ghfbcaijde

643 # if BASEMODEL_METADATA_TAG_KEY in info.metadata and BASEMODEL_METADATA_KEY not in info.metadata: 

644 # # We haven't processed the base class yet. Need another pass. 

645 # return None, None 

646 if METADATA_KEY not in info.metadata: 10 ctx1ghfbcaijde

647 continue 10 ctx1ghfbcaijde

648 

649 # Each class depends on the set of attributes in its dataclass ancestors. 

650 self._api.add_plugin_dependency(make_wildcard_trigger(info.fullname)) 10 ctx1ghfbcaijde

651 

652 for name, data in info.metadata[METADATA_KEY]['fields'].items(): 10 ctx1ghfbcaijde

653 field = PydanticModelField.deserialize(info, data, self._api) 10 ctx1ghfbcaijde

654 # (The following comment comes directly from the dataclasses plugin) 

655 # TODO: We shouldn't be performing type operations during the main 

656 # semantic analysis pass, since some TypeInfo attributes might 

657 # still be in flux. This should be performed in a later phase. 

658 field.expand_typevar_from_subtype(cls.info, self._api) 10 ctx1ghfbcaijde

659 found_fields[name] = field 10 ctx1ghfbcaijde

660 

661 sym_node = cls.info.names.get(name) 10 ctx1ghfbcaijde

662 if sym_node and sym_node.node and not isinstance(sym_node.node, Var): 662 ↛ 663line 662 didn't jump to line 663 because the condition on line 662 was never true10 ctx1ghfbcaijde

663 self._api.fail( 

664 'BaseModel field may only be overridden by another field', 

665 sym_node.node, 

666 ) 

667 # Collect ClassVars 

668 for name, data in info.metadata[METADATA_KEY]['class_vars'].items(): 668 ↛ 669line 668 didn't jump to line 669 because the loop on line 668 never started10 ctx1ghfbcaijde

669 found_class_vars[name] = PydanticModelClassVar.deserialize(data) 

670 

671 # Second, collect fields and ClassVars belonging to the current class. 

672 current_field_names: set[str] = set() 10 ctx1ghfbcaijde

673 current_class_vars_names: set[str] = set() 10 ctx1ghfbcaijde

674 for stmt in self._get_assignment_statements_from_block(cls.defs): 10 ctx1ghfbcaijde

675 maybe_field = self.collect_field_or_class_var_from_stmt(stmt, model_config, found_class_vars) 10 ctx1ghfbcaijde

676 if isinstance(maybe_field, PydanticModelField): 10 ctx1ghfbcaijde

677 lhs = stmt.lvalues[0] 10 ctx1ghfbcaijde

678 if is_root_model and lhs.name != 'root': 10 ctx1ghfbcaijde

679 error_extra_fields_on_root_model(self._api, stmt) 10 ctx1ghfbcaijde

680 else: 

681 current_field_names.add(lhs.name) 10 ctx1ghfbcaijde

682 found_fields[lhs.name] = maybe_field 10 ctx1ghfbcaijde

683 elif isinstance(maybe_field, PydanticModelClassVar): 10 ctx1ghfbcaijde

684 lhs = stmt.lvalues[0] 10 ctx1ghfbcaijde

685 current_class_vars_names.add(lhs.name) 10 ctx1ghfbcaijde

686 found_class_vars[lhs.name] = maybe_field 10 ctx1ghfbcaijde

687 

688 return list(found_fields.values()), list(found_class_vars.values()) 10 ctx1ghfbcaijde

689 

690 def _get_assignment_statements_from_if_statement(self, stmt: IfStmt) -> Iterator[AssignmentStmt]: 10 ctx1ghfbcaijde

691 for body in stmt.body: 10 ctx1ghfbcaijde

692 if not body.is_unreachable: 692 ↛ 691line 692 didn't jump to line 691 because the condition on line 692 was always true10 ctx1ghfbcaijde

693 yield from self._get_assignment_statements_from_block(body) 10 ctx1ghfbcaijde

694 if stmt.else_body is not None and not stmt.else_body.is_unreachable: 694 ↛ 695line 694 didn't jump to line 695 because the condition on line 694 was never true10 ctx1ghfbcaijde

695 yield from self._get_assignment_statements_from_block(stmt.else_body) 

696 

697 def _get_assignment_statements_from_block(self, block: Block) -> Iterator[AssignmentStmt]: 10 ctx1ghfbcaijde

698 for stmt in block.body: 10 ctx1ghfbcaijde

699 if isinstance(stmt, AssignmentStmt): 10 ctx1ghfbcaijde

700 yield stmt 10 ctx1ghfbcaijde

701 elif isinstance(stmt, IfStmt): 10 ctx1ghfbcaijde

702 yield from self._get_assignment_statements_from_if_statement(stmt) 10 ctx1ghfbcaijde

703 

704 def collect_field_or_class_var_from_stmt( # noqa C901 10 ctx1ghfbcaijde

705 self, stmt: AssignmentStmt, model_config: ModelConfigData, class_vars: dict[str, PydanticModelClassVar] 

706 ) -> PydanticModelField | PydanticModelClassVar | None: 

707 """Get pydantic model field from statement. 

708 

709 Args: 

710 stmt: The statement. 

711 model_config: Configuration settings for the model. 

712 class_vars: ClassVars already known to be defined on the model. 

713 

714 Returns: 

715 A pydantic model field if it could find the field in statement. Otherwise, `None`. 

716 """ 

717 cls = self._cls 10 ctx1ghfbcaijde

718 

719 lhs = stmt.lvalues[0] 10 ctx1ghfbcaijde

720 if not isinstance(lhs, NameExpr) or not _fields.is_valid_field_name(lhs.name) or lhs.name == 'model_config': 10 ctx1ghfbcaijde

721 return None 10 ctx1ghfbcaijde

722 

723 if not stmt.new_syntax: 10 ctx1ghfbcaijde

724 if ( 8 ctx1ghfbcaij

725 isinstance(stmt.rvalue, CallExpr) 

726 and isinstance(stmt.rvalue.callee, CallExpr)