Coverage for pydantic/_internal/_generate_schema.py: 95.09%

1"""Convert python types to pydantic-core schema.""" 

2 

3from __future__ import annotations as _annotations 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

4 

5import collections.abc 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

6import dataclasses 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

7import datetime 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

8import inspect 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

9import os 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

10import pathlib 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

11import re 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

12import sys 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

13import typing 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

14import warnings 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

15from collections.abc import Generator, Iterable, Iterator, Mapping 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

16from contextlib import contextmanager 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

17from copy import copy 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

18from decimal import Decimal 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

19from enum import Enum 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

20from fractions import Fraction 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

21from functools import partial 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

22from inspect import Parameter, _ParameterKind, signature 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

23from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

24from itertools import chain 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

25from operator import attrgetter 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

26from types import FunctionType, GenericAlias, LambdaType, MethodType 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

27from typing import ( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

28 TYPE_CHECKING, 

29 Any, 

30 Callable, 

31 Final, 

32 ForwardRef, 

33 Literal, 

34 TypeVar, 

35 Union, 

36 cast, 

37 overload, 

38) 

39from uuid import UUID 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

40from warnings import warn 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

41from zoneinfo import ZoneInfo 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

42 

43import typing_extensions 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

44from pydantic_core import ( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

45 CoreSchema, 

46 MultiHostUrl, 

47 PydanticCustomError, 

48 PydanticSerializationUnexpectedValue, 

49 PydanticUndefined, 

50 Url, 

51 core_schema, 

52 to_jsonable_python, 

53) 

54from typing_extensions import TypeAlias, TypeAliasType, TypedDict, get_args, get_origin, is_typeddict 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

55from typing_inspection import typing_objects 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

56from typing_inspection.introspection import AnnotationSource, get_literal_values, is_union_origin 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

57 

58from ..aliases import AliasChoices, AliasPath 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

59from ..annotated_handlers import GetCoreSchemaHandler, GetJsonSchemaHandler 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

60from ..config import ConfigDict, JsonDict, JsonEncoder, JsonSchemaExtraCallable 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

61from ..errors import PydanticSchemaGenerationError, PydanticUndefinedAnnotation, PydanticUserError 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

62from ..functional_validators import AfterValidator, BeforeValidator, FieldValidatorModes, PlainValidator, WrapValidator 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

63from ..json_schema import JsonSchemaValue 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

64from ..version import version_short 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

65from ..warnings import PydanticArbitraryTypeWarning, PydanticDeprecatedSince20 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

66from . import _decorators, _discriminated_union, _known_annotated_metadata, _repr, _typing_extra 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

67from ._config import ConfigWrapper, ConfigWrapperStack 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

68from ._core_metadata import CoreMetadata, update_core_metadata 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

69from ._core_utils import ( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

70 get_ref, 

71 get_type_ref, 

72 is_list_like_schema_with_items_schema, 

73) 

74from ._decorators import ( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

75 Decorator, 

76 DecoratorInfos, 

77 FieldSerializerDecoratorInfo, 

78 FieldValidatorDecoratorInfo, 

79 ModelSerializerDecoratorInfo, 

80 ModelValidatorDecoratorInfo, 

81 RootValidatorDecoratorInfo, 

82 ValidatorDecoratorInfo, 

83 get_attribute_from_bases, 

84 inspect_field_serializer, 

85 inspect_model_serializer, 

86 inspect_validator, 

87) 

88from ._docs_extraction import extract_docstrings_from_cls 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

89from ._fields import ( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

90 collect_dataclass_fields, 

91 rebuild_dataclass_fields, 

92 rebuild_model_fields, 

93 takes_validated_data_argument, 

94 update_field_from_config, 

95) 

96from ._forward_ref import PydanticRecursiveRef 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

97from ._generics import get_standard_typevars_map, replace_types 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

98from ._import_utils import import_cached_base_model, import_cached_field_info 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

99from ._mock_val_ser import MockCoreSchema 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

100from ._namespace_utils import NamespacesTuple, NsResolver 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

101from ._schema_gather import MissingDefinitionError, gather_schemas_for_cleaning 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

102from ._schema_generation_shared import CallbackGetCoreSchemaHandler 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

103from ._utils import lenient_issubclass, smart_deepcopy 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

104 

105if TYPE_CHECKING: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

106 from ..fields import ComputedFieldInfo, FieldInfo 

107 from ..main import BaseModel 

108 from ..types import Discriminator 

109 from ._dataclasses import StandardDataclass 

110 from ._schema_generation_shared import GetJsonSchemaFunction 

111 

112_SUPPORTS_TYPEDDICT = sys.version_info >= (3, 12) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

113 

114FieldDecoratorInfo = Union[ValidatorDecoratorInfo, FieldValidatorDecoratorInfo, FieldSerializerDecoratorInfo] 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

115FieldDecoratorInfoType = TypeVar('FieldDecoratorInfoType', bound=FieldDecoratorInfo) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

116AnyFieldDecorator = Union[ 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

117 Decorator[ValidatorDecoratorInfo], 

118 Decorator[FieldValidatorDecoratorInfo], 

119 Decorator[FieldSerializerDecoratorInfo], 

120] 

121 

122ModifyCoreSchemaWrapHandler: TypeAlias = GetCoreSchemaHandler 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

123GetCoreSchemaFunction: TypeAlias = Callable[[Any, ModifyCoreSchemaWrapHandler], core_schema.CoreSchema] 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

124ParametersCallback: TypeAlias = "Callable[[int, str, Any], Literal['skip'] | None]" 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

125 

126TUPLE_TYPES: list[type] = [typing.Tuple, tuple] # noqa: UP006 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

127LIST_TYPES: list[type] = [typing.List, list, collections.abc.MutableSequence] # noqa: UP006 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

128SET_TYPES: list[type] = [typing.Set, set, collections.abc.MutableSet] # noqa: UP006 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

129FROZEN_SET_TYPES: list[type] = [typing.FrozenSet, frozenset, collections.abc.Set] # noqa: UP006 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

130DICT_TYPES: list[type] = [typing.Dict, dict] # noqa: UP006 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

131IP_TYPES: list[type] = [IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network] 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

132SEQUENCE_TYPES: list[type] = [typing.Sequence, collections.abc.Sequence] 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

133ITERABLE_TYPES: list[type] = [typing.Iterable, collections.abc.Iterable, typing.Generator, collections.abc.Generator] 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

134TYPE_TYPES: list[type] = [typing.Type, type] # noqa: UP006 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

135PATTERN_TYPES: list[type] = [typing.Pattern, re.Pattern] 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

136PATH_TYPES: list[type] = [ 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

137 os.PathLike, 

138 pathlib.Path, 

139 pathlib.PurePath, 

140 pathlib.PosixPath, 

141 pathlib.PurePosixPath, 

142 pathlib.PureWindowsPath, 

143] 

144MAPPING_TYPES = [ 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

145 typing.Mapping, 

146 typing.MutableMapping, 

147 collections.abc.Mapping, 

148 collections.abc.MutableMapping, 

149 collections.OrderedDict, 

150 typing_extensions.OrderedDict, 

151 typing.DefaultDict, # noqa: UP006 

152 collections.defaultdict, 

153] 

154COUNTER_TYPES = [collections.Counter, typing.Counter] 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

155DEQUE_TYPES: list[type] = [collections.deque, typing.Deque] # noqa: UP006 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

156 

157# Note: This does not play very well with type checkers. For example, 

158# `a: LambdaType = lambda x: x` will raise a type error by Pyright. 

159ValidateCallSupportedTypes = Union[ 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

160 LambdaType, 

161 FunctionType, 

162 MethodType, 

163 partial, 

164] 

165 

166VALIDATE_CALL_SUPPORTED_TYPES = get_args(ValidateCallSupportedTypes) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

167 

168_mode_to_validator: dict[ 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

169 FieldValidatorModes, type[BeforeValidator | AfterValidator | PlainValidator | WrapValidator] 

170] = {'before': BeforeValidator, 'after': AfterValidator, 'plain': PlainValidator, 'wrap': WrapValidator} 

171 

172 

173def check_validator_fields_against_field_name( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

174 info: FieldDecoratorInfo, 

175 field: str, 

176) -> bool: 

177 """Check if field name is in validator fields. 

178 

179 Args: 

180 info: The field info. 

181 field: The field name to check. 

182 

183 Returns: 

184 `True` if field name is in validator fields, `False` otherwise. 

185 """ 

186 fields = info.fields 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

187 return '*' in fields or field in fields 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

188 

189 

190def check_decorator_fields_exist(decorators: Iterable[AnyFieldDecorator], fields: Iterable[str]) -> None: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

191 """Check if the defined fields in decorators exist in `fields` param. 

192 

193 It ignores the check for a decorator if the decorator has `*` as field or `check_fields=False`. 

194 

195 Args: 

196 decorators: An iterable of decorators. 

197 fields: An iterable of fields name. 

198 

199 Raises: 

200 PydanticUserError: If one of the field names does not exist in `fields` param. 

201 """ 

202 fields = set(fields) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

203 for dec in decorators: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

204 if '*' in dec.info.fields: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

205 continue 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

206 if dec.info.check_fields is False: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

207 continue 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

208 for field in dec.info.fields: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

209 if field not in fields: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

210 raise PydanticUserError( 38 ctx1abcfnquwAEBFoghijkrsxyGHIJdlemptvzCKDL

211 f'Decorators defined with incorrect fields: {dec.cls_ref}.{dec.cls_var_name}' 

212 " (use check_fields=False if you're inheriting from the model and intended this)", 

213 code='decorator-missing-field', 

214 ) 

215 

216 

217def filter_field_decorator_info_by_field( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

218 validator_functions: Iterable[Decorator[FieldDecoratorInfoType]], field: str 

219) -> list[Decorator[FieldDecoratorInfoType]]: 

220 return [dec for dec in validator_functions if check_validator_fields_against_field_name(dec.info, field)] 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

221 

222 

223def apply_each_item_validators( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

224 schema: core_schema.CoreSchema, 

225 each_item_validators: list[Decorator[ValidatorDecoratorInfo]], 

226) -> core_schema.CoreSchema: 

227 # This V1 compatibility shim should eventually be removed 

228 

229 # fail early if each_item_validators is empty 

230 if not each_item_validators: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

231 return schema 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

232 

233 # push down any `each_item=True` validators 

234 # note that this won't work for any Annotated types that get wrapped by a function validator 

235 # but that's okay because that didn't exist in V1 

236 if schema['type'] == 'nullable': 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

237 schema['schema'] = apply_each_item_validators(schema['schema'], each_item_validators) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

238 return schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

239 elif schema['type'] == 'tuple': 239 ↛ 240line 239 didn't jump to line 240 because the condition on line 239 was never true41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

240 if (variadic_item_index := schema.get('variadic_item_index')) is not None: 

241 schema['items_schema'][variadic_item_index] = apply_validators( 

242 schema['items_schema'][variadic_item_index], 

243 each_item_validators, 

244 ) 

245 elif is_list_like_schema_with_items_schema(schema): 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

246 inner_schema = schema.get('items_schema', core_schema.any_schema()) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

247 schema['items_schema'] = apply_validators(inner_schema, each_item_validators) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

248 elif schema['type'] == 'dict': 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

249 inner_schema = schema.get('values_schema', core_schema.any_schema()) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

250 schema['values_schema'] = apply_validators(inner_schema, each_item_validators) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

251 else: 

252 raise TypeError( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

253 f'`@validator(..., each_item=True)` cannot be applied to fields with a schema of {schema["type"]}' 

254 ) 

255 return schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

256 

257 

258def _extract_json_schema_info_from_field_info( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

259 info: FieldInfo | ComputedFieldInfo, 

260) -> tuple[JsonDict | None, JsonDict | JsonSchemaExtraCallable | None]: 

261 json_schema_updates = { 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

262 'title': info.title, 

263 'description': info.description, 

264 'deprecated': bool(info.deprecated) or info.deprecated == '' or None, 

265 'examples': to_jsonable_python(info.examples), 

266 } 

267 json_schema_updates = {k: v for k, v in json_schema_updates.items() if v is not None} 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

268 return (json_schema_updates or None, info.json_schema_extra) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

269 

270 

271JsonEncoders = dict[type[Any], JsonEncoder] 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

272 

273 

274def _add_custom_serialization_from_json_encoders( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

275 json_encoders: JsonEncoders | None, tp: Any, schema: CoreSchema 

276) -> CoreSchema: 

277 """Iterate over the json_encoders and add the first matching encoder to the schema. 

278 

279 Args: 

280 json_encoders: A dictionary of types and their encoder functions. 

281 tp: The type to check for a matching encoder. 

282 schema: The schema to add the encoder to. 

283 """ 

284 if not json_encoders: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

285 return schema 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

286 if 'serialization' in schema: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

287 return schema 38 ctx1abcfnquwAEBFoghijkrsxyGHIJdlemptvzCKDL

288 # Check the class type and its superclasses for a matching encoder 

289 # Decimal.__class__.__mro__ (and probably other cases) doesn't include Decimal itself 

290 # if the type is a GenericAlias (e.g. from list[int]) we need to use __class__ instead of .__mro__ 

291 for base in (tp, *getattr(tp, '__mro__', tp.__class__.__mro__)[:-1]): 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

292 encoder = json_encoders.get(base) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

293 if encoder is None: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

294 continue 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

295 

296 warnings.warn( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

297 f'`json_encoders` is deprecated. See https://docs.pydantic.dev/{version_short()}/concepts/serialization/#custom-serializers for alternatives', 

298 PydanticDeprecatedSince20, 

299 ) 

300 

301 # TODO: in theory we should check that the schema accepts a serialization key 

302 schema['serialization'] = core_schema.plain_serializer_function_ser_schema(encoder, when_used='json') 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

303 return schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

304 

305 return schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

306 

307 

308class InvalidSchemaError(Exception): 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

309 """The core schema is invalid.""" 

310 

311 

312class GenerateSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

313 """Generate core schema for a Pydantic model, dataclass and types like `str`, `datetime`, ... .""" 

314 

315 __slots__ = ( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

316 '_config_wrapper_stack', 

317 '_ns_resolver', 

318 '_typevars_map', 

319 'field_name_stack', 

320 'model_type_stack', 

321 'defs', 

322 ) 

323 

324 def __init__( 40 ctx1abcfnquwAEBFNhijkrsxyGHIJMPdlemptvzCKDLO

325 self, 

326 config_wrapper: ConfigWrapper, 

327 ns_resolver: NsResolver | None = None, 

328 typevars_map: Mapping[TypeVar, Any] | None = None, 

329 ) -> None: 

330 # we need a stack for recursing into nested models 

331 self._config_wrapper_stack = ConfigWrapperStack(config_wrapper) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

332 self._ns_resolver = ns_resolver or NsResolver() 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

333 self._typevars_map = typevars_map 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

334 self.field_name_stack = _FieldNameStack() 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

335 self.model_type_stack = _ModelTypeStack() 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

336 self.defs = _Definitions() 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

337 

338 def __init_subclass__(cls) -> None: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

339 super().__init_subclass__() 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

340 warnings.warn( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

341 'Subclassing `GenerateSchema` is not supported. The API is highly subject to change in minor versions.', 

342 UserWarning, 

343 stacklevel=2, 

344 ) 

345 

346 @property 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

347 def _config_wrapper(self) -> ConfigWrapper: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

348 return self._config_wrapper_stack.tail 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

349 

350 @property 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

351 def _types_namespace(self) -> NamespacesTuple: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

352 return self._ns_resolver.types_namespace 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

353 

354 @property 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

355 def _arbitrary_types(self) -> bool: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

356 return self._config_wrapper.arbitrary_types_allowed 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

357 

358 # the following methods can be overridden but should be considered 

359 # unstable / private APIs 

360 def _list_schema(self, items_type: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

361 return core_schema.list_schema(self.generate_schema(items_type)) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

362 

363 def _dict_schema(self, keys_type: Any, values_type: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

364 return core_schema.dict_schema(self.generate_schema(keys_type), self.generate_schema(values_type)) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

365 

366 def _set_schema(self, items_type: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

367 return core_schema.set_schema(self.generate_schema(items_type)) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

368 

369 def _frozenset_schema(self, items_type: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

370 return core_schema.frozenset_schema(self.generate_schema(items_type)) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

371 

372 def _enum_schema(self, enum_type: type[Enum]) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

373 cases: list[Any] = list(enum_type.__members__.values()) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

374 

375 enum_ref = get_type_ref(enum_type) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

376 description = None if not enum_type.__doc__ else inspect.cleandoc(enum_type.__doc__) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

377 if ( 4 ctx1abog

378 description == 'An enumeration.' 

379 ): # This is the default value provided by enum.EnumMeta.__new__; don't use it 

380 description = None 14 ctx1abcfoghijkdlem

381 js_updates = {'title': enum_type.__name__, 'description': description} 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

382 js_updates = {k: v for k, v in js_updates.items() if v is not None} 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

383 

384 sub_type: Literal['str', 'int', 'float'] | None = None 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

385 if issubclass(enum_type, int): 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

386 sub_type = 'int' 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

387 value_ser_type: core_schema.SerSchema = core_schema.simple_ser_schema('int') 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

388 elif issubclass(enum_type, str): 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

389 # this handles `StrEnum` (3.11 only), and also `Foobar(str, Enum)` 

390 sub_type = 'str' 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

391 value_ser_type = core_schema.simple_ser_schema('str') 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

392 elif issubclass(enum_type, float): 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

393 sub_type = 'float' 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

394 value_ser_type = core_schema.simple_ser_schema('float') 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

395 else: 

396 # TODO this is an ugly hack, how do we trigger an Any schema for serialization? 

397 value_ser_type = core_schema.plain_serializer_function_ser_schema(lambda x: x) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

398 

399 if cases: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

400 

401 def get_json_schema(schema: CoreSchema, handler: GetJsonSchemaHandler) -> JsonSchemaValue: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

402 json_schema = handler(schema) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

403 original_schema = handler.resolve_ref_schema(json_schema) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

404 original_schema.update(js_updates) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

405 return json_schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

406 

407 # we don't want to add the missing to the schema if it's the default one 

408 default_missing = getattr(enum_type._missing_, '__func__', None) is Enum._missing_.__func__ # pyright: ignore[reportFunctionMemberAccess] 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

409 enum_schema = core_schema.enum_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

410 enum_type, 

411 cases, 

412 sub_type=sub_type, 

413 missing=None if default_missing else enum_type._missing_, 

414 ref=enum_ref, 

415 metadata={'pydantic_js_functions': [get_json_schema]}, 

416 ) 

417 

418 if self._config_wrapper.use_enum_values: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

419 enum_schema = core_schema.no_info_after_validator_function( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

420 attrgetter('value'), enum_schema, serialization=value_ser_type 

421 ) 

422 

423 return enum_schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

424 

425 else: 

426 

427 def get_json_schema_no_cases(_, handler: GetJsonSchemaHandler) -> JsonSchemaValue: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

428 json_schema = handler(core_schema.enum_schema(enum_type, cases, sub_type=sub_type, ref=enum_ref)) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

429 original_schema = handler.resolve_ref_schema(json_schema) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

430 original_schema.update(js_updates) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

431 return json_schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

432 

433 # Use an isinstance check for enums with no cases. 

434 # The most important use case for this is creating TypeVar bounds for generics that should 

435 # be restricted to enums. This is more consistent than it might seem at first, since you can only 

436 # subclass enum.Enum (or subclasses of enum.Enum) if all parent classes have no cases. 

437 # We use the get_json_schema function when an Enum subclass has been declared with no cases 

438 # so that we can still generate a valid json schema. 

439 return core_schema.is_instance_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

440 enum_type, 

441 metadata={'pydantic_js_functions': [get_json_schema_no_cases]}, 

442 ) 

443 

444 def _ip_schema(self, tp: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

445 from ._validators import IP_VALIDATOR_LOOKUP, IpType 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

446 

447 ip_type_json_schema_format: dict[type[IpType], str] = { 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

448 IPv4Address: 'ipv4', 

449 IPv4Network: 'ipv4network', 

450 IPv4Interface: 'ipv4interface', 

451 IPv6Address: 'ipv6', 

452 IPv6Network: 'ipv6network', 

453 IPv6Interface: 'ipv6interface', 

454 } 

455 

456 def ser_ip(ip: Any, info: core_schema.SerializationInfo) -> str | IpType: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

457 if not isinstance(ip, (tp, str)): 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

458 raise PydanticSerializationUnexpectedValue( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

459 f"Expected `{tp}` but got `{type(ip)}` with value `'{ip}'` - serialized value may not be as expected." 

460 ) 

461 if info.mode == 'python': 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

462 return ip 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

463 return str(ip) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

464 

465 return core_schema.lax_or_strict_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

466 lax_schema=core_schema.no_info_plain_validator_function(IP_VALIDATOR_LOOKUP[tp]), 

467 strict_schema=core_schema.json_or_python_schema( 

468 json_schema=core_schema.no_info_after_validator_function(tp, core_schema.str_schema()), 

469 python_schema=core_schema.is_instance_schema(tp), 

470 ), 

471 serialization=core_schema.plain_serializer_function_ser_schema(ser_ip, info_arg=True, when_used='always'), 

472 metadata={ 

473 'pydantic_js_functions': [lambda _1, _2: {'type': 'string', 'format': ip_type_json_schema_format[tp]}] 

474 }, 

475 ) 

476 

477 def _path_schema(self, tp: Any, path_type: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

478 if tp is os.PathLike and (path_type not in {str, bytes} and not typing_objects.is_any(path_type)): 478 ↛ 479line 478 didn't jump to line 479 because the condition on line 478 was never true41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

479 raise PydanticUserError( 

480 '`os.PathLike` can only be used with `str`, `bytes` or `Any`', code='schema-for-unknown-type' 

481 ) 

482 

483 path_constructor = pathlib.PurePath if tp is os.PathLike else tp 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

484 strict_inner_schema = ( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

485 core_schema.bytes_schema(strict=True) if (path_type is bytes) else core_schema.str_schema(strict=True) 

486 ) 

487 lax_inner_schema = core_schema.bytes_schema() if (path_type is bytes) else core_schema.str_schema() 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

488 

489 def path_validator(input_value: str | bytes) -> os.PathLike[Any]: # type: ignore 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

490 try: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

491 if path_type is bytes: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

492 if isinstance(input_value, bytes): 492 ↛ 498line 492 didn't jump to line 498 because the condition on line 492 was always true41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

493 try: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

494 input_value = input_value.decode() 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

495 except UnicodeDecodeError as e: 

496 raise PydanticCustomError('bytes_type', 'Input must be valid bytes') from e 

497 else: 

498 raise PydanticCustomError('bytes_type', 'Input must be bytes') 

499 elif not isinstance(input_value, str): 499 ↛ 500line 499 didn't jump to line 500 because the condition on line 499 was never true41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

500 raise PydanticCustomError('path_type', 'Input is not a valid path') 

501 

502 return path_constructor(input_value) # type: ignore 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

503 except TypeError as e: 

504 raise PydanticCustomError('path_type', 'Input is not a valid path') from e 

505 

506 def ser_path(path: Any, info: core_schema.SerializationInfo) -> str | os.PathLike[Any]: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

507 if not isinstance(path, (tp, str)): 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

508 raise PydanticSerializationUnexpectedValue( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

509 f"Expected `{tp}` but got `{type(path)}` with value `'{path}'` - serialized value may not be as expected." 

510 ) 

511 if info.mode == 'python': 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

512 return path 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

513 return str(path) 39 ctx1abcfnquwAEBFoghijkrsxyGHIJMdlemptvzCKDL

514 

515 instance_schema = core_schema.json_or_python_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

516 json_schema=core_schema.no_info_after_validator_function(path_validator, lax_inner_schema), 

517 python_schema=core_schema.is_instance_schema(tp), 

518 ) 

519 

520 schema = core_schema.lax_or_strict_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

521 lax_schema=core_schema.union_schema( 

522 [ 

523 instance_schema, 

524 core_schema.no_info_after_validator_function(path_validator, strict_inner_schema), 

525 ], 

526 custom_error_type='path_type', 

527 custom_error_message=f'Input is not a valid path for {tp}', 

528 ), 

529 strict_schema=instance_schema, 

530 serialization=core_schema.plain_serializer_function_ser_schema(ser_path, info_arg=True, when_used='always'), 

531 metadata={'pydantic_js_functions': [lambda source, handler: {**handler(source), 'format': 'path'}]}, 

532 ) 

533 return schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

534 

535 def _deque_schema(self, items_type: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

536 from ._serializers import serialize_sequence_via_list 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

537 from ._validators import deque_validator 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

538 

539 item_type_schema = self.generate_schema(items_type) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

540 

541 # we have to use a lax list schema here, because we need to validate the deque's 

542 # items via a list schema, but it's ok if the deque itself is not a list 

543 list_schema = core_schema.list_schema(item_type_schema, strict=False) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

544 

545 check_instance = core_schema.json_or_python_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

546 json_schema=list_schema, 

547 python_schema=core_schema.is_instance_schema(collections.deque, cls_repr='Deque'), 

548 ) 

549 

550 lax_schema = core_schema.no_info_wrap_validator_function(deque_validator, list_schema) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

551 

552 return core_schema.lax_or_strict_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

553 lax_schema=lax_schema, 

554 strict_schema=core_schema.chain_schema([check_instance, lax_schema]), 

555 serialization=core_schema.wrap_serializer_function_ser_schema( 

556 serialize_sequence_via_list, schema=item_type_schema, info_arg=True 

557 ), 

558 ) 

559 

560 def _mapping_schema(self, tp: Any, keys_type: Any, values_type: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

561 from ._validators import MAPPING_ORIGIN_MAP, defaultdict_validator, get_defaultdict_default_default_factory 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

562 

563 mapped_origin = MAPPING_ORIGIN_MAP[tp] 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

564 keys_schema = self.generate_schema(keys_type) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

565 values_schema = self.generate_schema(values_type) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

566 dict_schema = core_schema.dict_schema(keys_schema, values_schema, strict=False) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

567 

568 if mapped_origin is dict: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

569 schema = dict_schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

570 else: 

571 check_instance = core_schema.json_or_python_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

572 json_schema=dict_schema, 

573 python_schema=core_schema.is_instance_schema(mapped_origin), 

574 ) 

575 

576 if tp is collections.defaultdict: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

577 default_default_factory = get_defaultdict_default_default_factory(values_type) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

578 coerce_instance_wrap = partial( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

579 core_schema.no_info_wrap_validator_function, 

580 partial(defaultdict_validator, default_default_factory=default_default_factory), 

581 ) 

582 else: 

583 coerce_instance_wrap = partial(core_schema.no_info_after_validator_function, mapped_origin) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

584 

585 lax_schema = coerce_instance_wrap(dict_schema) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

586 strict_schema = core_schema.chain_schema([check_instance, lax_schema]) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

587 

588 schema = core_schema.lax_or_strict_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

589 lax_schema=lax_schema, 

590 strict_schema=strict_schema, 

591 serialization=core_schema.wrap_serializer_function_ser_schema( 

592 lambda v, h: h(v), schema=dict_schema, info_arg=False 

593 ), 

594 ) 

595 

596 return schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

597 

598 def _fraction_schema(self) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

599 """Support for [`fractions.Fraction`][fractions.Fraction].""" 

600 from ._validators import fraction_validator 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

601 

602 # TODO: note, this is a fairly common pattern, re lax / strict for attempted type coercion, 

603 # can we use a helper function to reduce boilerplate? 

604 return core_schema.lax_or_strict_schema( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

605 lax_schema=core_schema.no_info_plain_validator_function(fraction_validator), 

606 strict_schema=core_schema.json_or_python_schema( 

607 json_schema=core_schema.no_info_plain_validator_function(fraction_validator), 

608 python_schema=core_schema.is_instance_schema(Fraction), 

609 ), 

610 # use str serialization to guarantee round trip behavior 

611 serialization=core_schema.to_string_ser_schema(when_used='always'), 

612 metadata={'pydantic_js_functions': [lambda _1, _2: {'type': 'string', 'format': 'fraction'}]}, 

613 ) 

614 

615 def _arbitrary_type_schema(self, tp: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

616 if not isinstance(tp, type): 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

617 warn( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

618 f'{tp!r} is not a Python type (it may be an instance of an object),' 

619 ' Pydantic will allow any object with no validation since we cannot even' 

620 ' enforce that the input is an instance of the given type.' 

621 ' To get rid of this error wrap the type with `pydantic.SkipValidation`.', 

622 PydanticArbitraryTypeWarning, 

623 ) 

624 return core_schema.any_schema() 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

625 return core_schema.is_instance_schema(tp) 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

626 

627 def _unknown_type_schema(self, obj: Any) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

628 raise PydanticSchemaGenerationError( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

629 f'Unable to generate pydantic-core schema for {obj!r}. ' 

630 'Set `arbitrary_types_allowed=True` in the model_config to ignore this error' 

631 ' or implement `__get_pydantic_core_schema__` on your type to fully support it.' 

632 '\n\nIf you got this error by calling handler(<some type>) within' 

633 ' `__get_pydantic_core_schema__` then you likely need to call' 

634 ' `handler.generate_schema(<some type>)` since we do not call' 

635 ' `__get_pydantic_core_schema__` on `<some type>` otherwise to avoid infinite recursion.' 

636 ) 

637 

638 def _apply_discriminator_to_union( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

639 self, schema: CoreSchema, discriminator: str | Discriminator | None 

640 ) -> CoreSchema: 

641 if discriminator is None: 641 ↛ 642line 641 didn't jump to line 642 because the condition on line 641 was never true41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

642 return schema 

643 try: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

644 return _discriminated_union.apply_discriminator( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

645 schema, 

646 discriminator, 

647 self.defs._definitions, 

648 ) 

649 except _discriminated_union.MissingDefinitionForUnionRef: 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

650 # defer until defs are resolved 

651 _discriminated_union.set_discriminator_in_metadata( 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

652 schema, 

653 discriminator, 

654 ) 

655 return schema 41 ctx1abcfnquwAEBFNoghijkrsxyGHIJMdlemptvzCKDLO

656 

657 def clean_schema(self, schema: CoreSchema) -> CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

658 return self.defs.finalize_schema(schema) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

659 

660 def _add_js_function(self, metadata_schema: CoreSchema, js_function: Callable[..., Any]) -> None: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

661 metadata = metadata_schema.get('metadata', {}) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

662 pydantic_js_functions = metadata.setdefault('pydantic_js_functions', []) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

663 # because of how we generate core schemas for nested generic models 

664 # we can end up adding `BaseModel.__get_pydantic_json_schema__` multiple times 

665 # this check may fail to catch duplicates if the function is a `functools.partial` 

666 # or something like that, but if it does it'll fail by inserting the duplicate 

667 if js_function not in pydantic_js_functions: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

668 pydantic_js_functions.append(js_function) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

669 metadata_schema['metadata'] = metadata 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

670 

671 def generate_schema( 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

672 self, 

673 obj: Any, 

674 ) -> core_schema.CoreSchema: 

675 """Generate core schema. 

676 

677 Args: 

678 obj: The object to generate core schema for. 

679 

680 Returns: 

681 The generated core schema. 

682 

683 Raises: 

684 PydanticUndefinedAnnotation: 

685 If it is not possible to evaluate forward reference. 

686 PydanticSchemaGenerationError: 

687 If it is not possible to generate pydantic-core schema. 

688 TypeError: 

689 - If `alias_generator` returns a disallowed type (must be str, AliasPath or AliasChoices). 

690 - If V1 style validator with `each_item=True` applied on a wrong field. 

691 PydanticUserError: 

692 - If `typing.TypedDict` is used instead of `typing_extensions.TypedDict` on Python < 3.12. 

693 - If `__modify_schema__` method is used instead of `__get_pydantic_json_schema__`. 

694 """ 

695 schema = self._generate_schema_from_get_schema_method(obj, obj) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

696 

697 if schema is None: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

698 schema = self._generate_schema_inner(obj) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

699 

700 metadata_js_function = _extract_get_pydantic_json_schema(obj) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

701 if metadata_js_function is not None: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

702 metadata_schema = resolve_original_schema(schema, self.defs) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

703 if metadata_schema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

704 self._add_js_function(metadata_schema, metadata_js_function) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

705 

706 schema = _add_custom_serialization_from_json_encoders(self._config_wrapper.json_encoders, obj, schema) 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

707 

708 return schema 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

709 

710 def _model_schema(self, cls: type[BaseModel]) -> core_schema.CoreSchema: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

711 """Generate schema for a Pydantic model.""" 

712 BaseModel_ = import_cached_base_model() 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

713 

714 with self.defs.get_schema_or_ref(cls) as (model_ref, maybe_schema): 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

715 if maybe_schema is not None: 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO

716 return maybe_schema 42 ctx1abcfnquwAEBFNoghijkrsxyGHIJMPdlemptvzCKDLO