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

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

2 

3from __future__ import annotations as _annotations 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

4 

5import collections.abc 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

6import dataclasses 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

7import datetime 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

8import inspect 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

9import os 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

10import pathlib 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

11import re 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

12import sys 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

13import typing 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

14import warnings 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

16from contextlib import contextmanager 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

17from copy import copy 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

18from decimal import Decimal 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

19from enum import Enum 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

20from fractions import Fraction 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

21from functools import partial 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

22from inspect import Parameter, _ParameterKind, signature 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

24from itertools import chain 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

25from operator import attrgetter 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

27from typing import ( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

40from warnings import warn 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

41from zoneinfo import ZoneInfo 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

42 

43import typing_extensions 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

44from pydantic_core import ( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

55from typing_inspection import typing_objects 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

57 

58from ..aliases import AliasChoices, AliasPath 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

59from ..annotated_handlers import GetCoreSchemaHandler, GetJsonSchemaHandler 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

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

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

63from ..json_schema import JsonSchemaValue 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

64from ..version import version_short 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

65from ..warnings import PydanticDeprecatedSince20 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

67from ._config import ConfigWrapper, ConfigWrapperStack 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

68from ._core_metadata import CoreMetadata, update_core_metadata 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

69from ._core_utils import ( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

70 get_ref, 

71 get_type_ref, 

72 is_list_like_schema_with_items_schema, 

73 validate_core_schema, 

74) 

75from ._decorators import ( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

76 Decorator, 

77 DecoratorInfos, 

78 FieldSerializerDecoratorInfo, 

79 FieldValidatorDecoratorInfo, 

80 ModelSerializerDecoratorInfo, 

81 ModelValidatorDecoratorInfo, 

82 RootValidatorDecoratorInfo, 

83 ValidatorDecoratorInfo, 

84 get_attribute_from_bases, 

85 inspect_field_serializer, 

86 inspect_model_serializer, 

87 inspect_validator, 

88) 

89from ._docs_extraction import extract_docstrings_from_cls 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

90from ._fields import ( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

91 collect_dataclass_fields, 

92 rebuild_model_fields, 

93 takes_validated_data_argument, 

94 update_field_from_config, 

95) 

96from ._forward_ref import PydanticRecursiveRef 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

97from ._generics import get_standard_typevars_map, replace_types 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

98from ._import_utils import import_cached_base_model, import_cached_field_info 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

99from ._mock_val_ser import MockCoreSchema 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

100from ._namespace_utils import NamespacesTuple, NsResolver 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

101from ._schema_gather import MissingDefinitionError, gather_schemas_for_cleaning 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

102from ._schema_generation_shared import CallbackGetCoreSchemaHandler 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

103from ._utils import lenient_issubclass, smart_deepcopy 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

104 

105if TYPE_CHECKING: 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

113 

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

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

116AnyFieldDecorator = Union[ 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

117 Decorator[ValidatorDecoratorInfo], 

118 Decorator[FieldValidatorDecoratorInfo], 

119 Decorator[FieldSerializerDecoratorInfo], 

120] 

121 

122ModifyCoreSchemaWrapHandler: TypeAlias = GetCoreSchemaHandler 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

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

125 

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

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

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

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

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

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

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

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

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

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

136PATH_TYPES: list[type] = [ 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

137 os.PathLike, 

138 pathlib.Path, 

139 pathlib.PurePath, 

140 pathlib.PosixPath, 

141 pathlib.PurePosixPath, 

142 pathlib.PureWindowsPath, 

143] 

144MAPPING_TYPES = [ 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

160 LambdaType, 

161 FunctionType, 

162 MethodType, 

163 partial, 

164] 

165 

166VALIDATE_CALL_SUPPORTED_TYPES = get_args(ValidateCallSupportedTypes) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

167 

168_mode_to_validator: dict[ 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

188 

189 

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

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

203 for dec in decorators: 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

205 continue 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

207 continue 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

209 if field not in fields: 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

210 raise PydanticUserError( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

221 

222 

223def apply_each_item_validators( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

231 return schema 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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': 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

237 schema['schema'] = apply_each_item_validators(schema['schema'], each_item_validators) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

238 return schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

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): 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

246 inner_schema = schema.get('items_schema', core_schema.any_schema()) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

247 schema['items_schema'] = apply_validators(inner_schema, each_item_validators) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

248 elif schema['type'] == 'dict': 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

249 inner_schema = schema.get('values_schema', core_schema.any_schema()) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

250 schema['values_schema'] = apply_validators(inner_schema, each_item_validators) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

251 else: 

252 raise TypeError( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

254 ) 

255 return schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

256 

257 

258def _extract_json_schema_info_from_field_info( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

259 info: FieldInfo | ComputedFieldInfo, 

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

261 json_schema_updates = { 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

269 

270 

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

272 

273 

274def _add_custom_serialization_from_json_encoders( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

285 return schema 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

286 if 'serialization' in schema: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

287 return schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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]): 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

292 encoder = json_encoders.get(base) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

293 if encoder is None: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

294 continue 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

295 

296 warnings.warn( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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') 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

303 return schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

304 

305 return schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

306 

307 

308class InvalidSchemaError(Exception): 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

310 

311 

312class GenerateSchema: 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

314 

315 __slots__ = ( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDhijkrsxyEFGOJKLMNPdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

333 self._typevars_map = typevars_map 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

334 self.field_name_stack = _FieldNameStack() 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

335 self.model_type_stack = _ModelTypeStack() 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

336 self.defs = _Definitions() 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

337 

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

339 super().__init_subclass__() 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

340 warnings.warn( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

348 return self._config_wrapper_stack.tail 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

349 

350 @property 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

352 return self._ns_resolver.types_namespace 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

353 

354 @property 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

356 return self._config_wrapper.arbitrary_types_allowed 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

362 

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

364 return core_schema.dict_schema(self.generate_schema(keys_type), self.generate_schema(values_type)) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

365 

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

367 return core_schema.set_schema(self.generate_schema(items_type)) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

368 

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

370 return core_schema.frozenset_schema(self.generate_schema(items_type)) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

371 

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

373 cases: list[Any] = list(enum_type.__members__.values()) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

374 

375 enum_ref = get_type_ref(enum_type) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

376 description = None if not enum_type.__doc__ else inspect.cleandoc(enum_type.__doc__) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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} 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

383 

384 sub_type: Literal['str', 'int', 'float'] | None = None 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

385 if issubclass(enum_type, int): 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

386 sub_type = 'int' 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

387 value_ser_type: core_schema.SerSchema = core_schema.simple_ser_schema('int') 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

388 elif issubclass(enum_type, str): 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

390 sub_type = 'str' 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

391 value_ser_type = core_schema.simple_ser_schema('str') 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

392 elif issubclass(enum_type, float): 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

393 sub_type = 'float' 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

394 value_ser_type = core_schema.simple_ser_schema('float') 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

398 

399 if cases: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

400 

401 def get_json_schema(schema: CoreSchema, handler: GetJsonSchemaHandler) -> JsonSchemaValue: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

402 json_schema = handler(schema) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

403 original_schema = handler.resolve_ref_schema(json_schema) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

404 original_schema.update(js_updates) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

405 return json_schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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] 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

409 enum_schema = core_schema.enum_schema( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

419 enum_schema = core_schema.no_info_after_validator_function( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

421 ) 

422 

423 return enum_schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

424 

425 else: 

426 

427 def get_json_schema_no_cases(_, handler: GetJsonSchemaHandler) -> JsonSchemaValue: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

428 json_schema = handler(core_schema.enum_schema(enum_type, cases, sub_type=sub_type, ref=enum_ref)) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

429 original_schema = handler.resolve_ref_schema(json_schema) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

430 original_schema.update(js_updates) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

431 return json_schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

440 enum_type, 

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

442 ) 

443 

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

445 from ._validators import IP_VALIDATOR_LOOKUP, IpType 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

446 

447 ip_type_json_schema_format: dict[type[IpType], str] = { 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

457 if not isinstance(ip, (tp, str)): 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

458 raise PydanticSerializationUnexpectedValue( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

460 ) 

461 if info.mode == 'python': 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

462 return ip 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

463 return str(ip) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

464 

465 return core_schema.lax_or_strict_schema( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 true35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

484 strict_inner_schema = ( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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() 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

488 

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

490 try: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

491 if path_type is bytes: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

493 try: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

494 input_value = input_value.decode() 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 true35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

501 

502 return path_constructor(input_value) # type: ignore 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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]: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

507 if not isinstance(path, (tp, str)): 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

508 raise PydanticSerializationUnexpectedValue( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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

510 ) 

511 if info.mode == 'python': 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

512 return path 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

513 return str(path) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

514 

515 instance_schema = core_schema.json_or_python_schema( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

534 

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

536 from ._serializers import serialize_sequence_via_list 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

537 from ._validators import deque_validator 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

538 

539 item_type_schema = self.generate_schema(items_type) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

544 

545 check_instance = core_schema.json_or_python_schema( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

551 

552 return core_schema.lax_or_strict_schema( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

561 from ._validators import MAPPING_ORIGIN_MAP, defaultdict_validator, get_defaultdict_default_default_factory 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

562 

563 mapped_origin = MAPPING_ORIGIN_MAP[tp] 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

564 keys_schema = self.generate_schema(keys_type) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

565 values_schema = self.generate_schema(values_type) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

566 dict_schema = core_schema.dict_schema(keys_schema, values_schema, strict=False) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

567 

568 if mapped_origin is dict: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

569 schema = dict_schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

570 else: 

571 check_instance = core_schema.json_or_python_schema( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

572 json_schema=dict_schema, 

573 python_schema=core_schema.is_instance_schema(mapped_origin), 

574 ) 

575 

576 if tp is collections.defaultdict: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

577 default_default_factory = get_defaultdict_default_default_factory(values_type) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

578 coerce_instance_wrap = partial( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

584 

585 lax_schema = coerce_instance_wrap(dict_schema) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

586 strict_schema = core_schema.chain_schema([check_instance, lax_schema]) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

587 

588 schema = core_schema.lax_or_strict_schema( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

597 

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

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

600 from ._validators import fraction_validator 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

616 if not isinstance(tp, type): 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

617 warn( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 UserWarning, 

623 ) 

624 return core_schema.any_schema() 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

625 return core_schema.is_instance_schema(tp) 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

626 

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

628 raise PydanticSchemaGenerationError( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

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 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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 true35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

642 return schema 

643 try: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

644 return _discriminated_union.apply_discriminator( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

645 schema, 

646 discriminator, 

647 self.defs._definitions, 

648 ) 

649 except _discriminated_union.MissingDefinitionForUnionRef: 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

650 # defer until defs are resolved 

651 _discriminated_union.set_discriminator_in_metadata( 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

652 schema, 

653 discriminator, 

654 ) 

655 return schema 35 ctx1abcfnquwACDoghijkrsxyEFGdlemptvzBHI

656 

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

658 schema = self.defs.finalize_schema(schema) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

659 schema = validate_core_schema(schema) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

660 return schema 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

661 

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

663 metadata = metadata_schema.get('metadata', {}) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

664 pydantic_js_functions = metadata.setdefault('pydantic_js_functions', []) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

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

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

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

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

669 if js_function not in pydantic_js_functions: 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

670 pydantic_js_functions.append(js_function) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

671 metadata_schema['metadata'] = metadata 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

672 

673 def generate_schema( 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

674 self, 

675 obj: Any, 

676 ) -> core_schema.CoreSchema: 

677 """Generate core schema. 

678 

679 Args: 

680 obj: The object to generate core schema for. 

681 

682 Returns: 

683 The generated core schema. 

684 

685 Raises: 

686 PydanticUndefinedAnnotation: 

687 If it is not possible to evaluate forward reference. 

688 PydanticSchemaGenerationError: 

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

690 TypeError: 

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

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

693 PydanticUserError: 

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

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

696 """ 

697 schema = self._generate_schema_from_get_schema_method(obj, obj) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

698 

699 if schema is None: 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

700 schema = self._generate_schema_inner(obj) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

701 

702 metadata_js_function = _extract_get_pydantic_json_schema(obj) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

703 if metadata_js_function is not None: 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

704 metadata_schema = resolve_original_schema(schema, self.defs) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

705 if metadata_schema: 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

706 self._add_js_function(metadata_schema, metadata_js_function) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

707 

708 schema = _add_custom_serialization_from_json_encoders(self._config_wrapper.json_encoders, obj, schema) 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

709 

710 return schema 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

711 

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

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

714 BaseModel_ = import_cached_base_model() 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI

715 

716 with self.defs.get_schema_or_ref(cls) as (model_ref, maybe_schema): 42 ctx1abcfnquwACDoghijkrsxyEFGOJKLMNPdlemptvzBHI