Coverage for pydantic/json_schema.py: 94.54%

1"""!!! abstract "Usage Documentation" 

2 [JSON Schema](../concepts/json_schema.md) 

3 

4The `json_schema` module contains classes and functions to allow the way [JSON Schema](https://json-schema.org/) 

5is generated to be customized. 

6 

7In general you shouldn't need to use this module directly; instead, you can use 

8[`BaseModel.model_json_schema`][pydantic.BaseModel.model_json_schema] and 

9[`TypeAdapter.json_schema`][pydantic.TypeAdapter.json_schema]. 

10""" 

11 

12from __future__ import annotations as _annotations 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

13 

14import dataclasses 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

15import inspect 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

16import math 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

17import os 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

18import re 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

19import warnings 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

20from collections import Counter, defaultdict 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

21from collections.abc import Hashable, Iterable, Sequence 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

22from copy import deepcopy 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

23from enum import Enum 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

24from re import Pattern 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

25from typing import ( 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

26 TYPE_CHECKING, 

27 Annotated, 

28 Any, 

29 Callable, 

30 Literal, 

31 NewType, 

32 TypeVar, 

33 Union, 

34 cast, 

35 overload, 

36) 

37 

38import pydantic_core 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

39from pydantic_core import CoreSchema, PydanticOmit, core_schema, to_jsonable_python 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

40from pydantic_core.core_schema import ComputedField 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

41from typing_extensions import TypeAlias, assert_never, deprecated, final 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

42from typing_inspection.introspection import get_literal_values 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

43 

44from pydantic.warnings import PydanticDeprecatedSince26, PydanticDeprecatedSince29 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

45 

46from ._internal import ( 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

47 _config, 

48 _core_metadata, 

49 _core_utils, 

50 _decorators, 

51 _internal_dataclass, 

52 _mock_val_ser, 

53 _schema_generation_shared, 

54) 

55from .annotated_handlers import GetJsonSchemaHandler 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

56from .config import JsonDict, JsonValue 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

57from .errors import PydanticInvalidForJsonSchema, PydanticSchemaGenerationError, PydanticUserError 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

58 

59if TYPE_CHECKING: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

60 from . import ConfigDict 

61 from ._internal._core_utils import CoreSchemaField, CoreSchemaOrField 

62 from ._internal._dataclasses import PydanticDataclass 

63 from ._internal._schema_generation_shared import GetJsonSchemaFunction 

64 from .main import BaseModel 

65 

66 

67CoreSchemaOrFieldType = Literal[core_schema.CoreSchemaType, core_schema.CoreSchemaFieldType] 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

68""" 34 ctx1bhiycjdklamnzAopqrsNOJKLMetuBfvgwx

69A type alias for defined schema types that represents a union of 

70`core_schema.CoreSchemaType` and 

71`core_schema.CoreSchemaFieldType`. 

72""" 

73 

74JsonSchemaValue = dict[str, Any] 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

75""" 34 ctx1bhiycjdklamnzAopqrsNOJKLMetuBfvgwx

76A type alias for a JSON schema value. This is a dictionary of string keys to arbitrary JSON values. 

77""" 

78 

79JsonSchemaMode = Literal['validation', 'serialization'] 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

80""" 34 ctx1bhiycjdklamnzAopqrsNOJKLMetuBfvgwx

81A type alias that represents the mode of a JSON schema; either 'validation' or 'serialization'. 

82 

83For some types, the inputs to validation differ from the outputs of serialization. For example, 

84computed fields will only be present when serializing, and should not be provided when 

85validating. This flag provides a way to indicate whether you want the JSON schema required 

86for validation inputs, or that will be matched by serialization outputs. 

87""" 

88 

89_MODE_TITLE_MAPPING: dict[JsonSchemaMode, str] = {'validation': 'Input', 'serialization': 'Output'} 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

90 

91 

92JsonSchemaWarningKind = Literal['skipped-choice', 'non-serializable-default', 'skipped-discriminator'] 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

93""" 34 ctx1bhiycjdklamnzAopqrsNOJKLMetuBfvgwx

94A type alias representing the kinds of warnings that can be emitted during JSON schema generation. 

95 

96See [`GenerateJsonSchema.render_warning_message`][pydantic.json_schema.GenerateJsonSchema.render_warning_message] 

97for more details. 

98""" 

99 

100 

101class PydanticJsonSchemaWarning(UserWarning): 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

102 """This class is used to emit warnings produced during JSON schema generation. 

103 See the [`GenerateJsonSchema.emit_warning`][pydantic.json_schema.GenerateJsonSchema.emit_warning] and 

104 [`GenerateJsonSchema.render_warning_message`][pydantic.json_schema.GenerateJsonSchema.render_warning_message] 

105 methods for more details; these can be overridden to control warning behavior. 

106 """ 

107 

108 

109NoDefault = object() 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

110"""A sentinel value used to indicate that no default value should be used when generating a JSON Schema 34 ctx1bhiycjdklamnzAopqrsNOJKLMetuBfvgwx

111for a core schema with a default value. 

112""" 

113 

114 

115# ##### JSON Schema Generation ##### 

116DEFAULT_REF_TEMPLATE = '#/$defs/{model}' 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

117"""The default format string used to generate reference names.""" 34 ctx1bhiycjdklamnzAopqrsNOJKLMetuBfvgwx

118 

119# There are three types of references relevant to building JSON schemas: 

120# 1. core_schema "ref" values; these are not exposed as part of the JSON schema 

121# * these might look like the fully qualified path of a model, its id, or something similar 

122CoreRef = NewType('CoreRef', str) 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

123# 2. keys of the "definitions" object that will eventually go into the JSON schema 

124# * by default, these look like "MyModel", though may change in the presence of collisions 

125# * eventually, we may want to make it easier to modify the way these names are generated 

126DefsRef = NewType('DefsRef', str) 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

127# 3. the values corresponding to the "$ref" key in the schema 

128# * By default, these look like "#/$defs/MyModel", as in {"$ref": "#/$defs/MyModel"} 

129JsonRef = NewType('JsonRef', str) 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

130 

131CoreModeRef = tuple[CoreRef, JsonSchemaMode] 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

132JsonSchemaKeyT = TypeVar('JsonSchemaKeyT', bound=Hashable) 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

133 

134 

135@dataclasses.dataclass(**_internal_dataclass.slots_true) 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

136class _DefinitionsRemapping: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

137 defs_remapping: dict[DefsRef, DefsRef] 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

138 json_remapping: dict[JsonRef, JsonRef] 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

139 

140 @staticmethod 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

141 def from_prioritized_choices( 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

142 prioritized_choices: dict[DefsRef, list[DefsRef]], 

143 defs_to_json: dict[DefsRef, JsonRef], 

144 definitions: dict[DefsRef, JsonSchemaValue], 

145 ) -> _DefinitionsRemapping: 

146 """ 

147 This function should produce a remapping that replaces complex DefsRef with the simpler ones from the 

148 prioritized_choices such that applying the name remapping would result in an equivalent JSON schema. 

149 """ 

150 # We need to iteratively simplify the definitions until we reach a fixed point. 

151 # The reason for this is that outer definitions may reference inner definitions that get simplified 

152 # into an equivalent reference, and the outer definitions won't be equivalent until we've simplified 

153 # the inner definitions. 

154 copied_definitions = deepcopy(definitions) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

155 definitions_schema = {'$defs': copied_definitions} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

156 for _iter in range(100): # prevent an infinite loop in the case of a bug, 100 iterations should be enough 156 ↛ 185line 156 didn't jump to line 185 because the loop on line 156 didn't complete35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

157 # For every possible remapped DefsRef, collect all schemas that that DefsRef might be used for: 

158 schemas_for_alternatives: dict[DefsRef, list[JsonSchemaValue]] = defaultdict(list) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

159 for defs_ref in copied_definitions: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

160 alternatives = prioritized_choices[defs_ref] 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

161 for alternative in alternatives: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

162 schemas_for_alternatives[alternative].append(copied_definitions[defs_ref]) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

163 

164 # Deduplicate the schemas for each alternative; the idea is that we only want to remap to a new DefsRef 

165 # if it introduces no ambiguity, i.e., there is only one distinct schema for that DefsRef. 

166 for defs_ref in schemas_for_alternatives: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

167 schemas_for_alternatives[defs_ref] = _deduplicate_schemas(schemas_for_alternatives[defs_ref]) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

168 

169 # Build the remapping 

170 defs_remapping: dict[DefsRef, DefsRef] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

171 json_remapping: dict[JsonRef, JsonRef] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

172 for original_defs_ref in definitions: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

173 alternatives = prioritized_choices[original_defs_ref] 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

174 # Pick the first alternative that has only one schema, since that means there is no collision 

175 remapped_defs_ref = next(x for x in alternatives if len(schemas_for_alternatives[x]) == 1) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

176 defs_remapping[original_defs_ref] = remapped_defs_ref 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

177 json_remapping[defs_to_json[original_defs_ref]] = defs_to_json[remapped_defs_ref] 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

178 remapping = _DefinitionsRemapping(defs_remapping, json_remapping) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

179 new_definitions_schema = remapping.remap_json_schema({'$defs': copied_definitions}) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

180 if definitions_schema == new_definitions_schema: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

181 # We've reached the fixed point 

182 return remapping 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

183 definitions_schema = new_definitions_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

184 

185 raise PydanticInvalidForJsonSchema('Failed to simplify the JSON schema definitions') 

186 

187 def remap_defs_ref(self, ref: DefsRef) -> DefsRef: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

188 return self.defs_remapping.get(ref, ref) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

189 

190 def remap_json_ref(self, ref: JsonRef) -> JsonRef: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

191 return self.json_remapping.get(ref, ref) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

192 

193 def remap_json_schema(self, schema: Any) -> Any: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

194 """ 

195 Recursively update the JSON schema replacing all $refs 

196 """ 

197 if isinstance(schema, str): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

198 # Note: this may not really be a JsonRef; we rely on having no collisions between JsonRefs and other strings 

199 return self.remap_json_ref(JsonRef(schema)) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

200 elif isinstance(schema, list): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

201 return [self.remap_json_schema(item) for item in schema] 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

202 elif isinstance(schema, dict): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

203 for key, value in schema.items(): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

204 if key == '$ref' and isinstance(value, str): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

205 schema['$ref'] = self.remap_json_ref(JsonRef(value)) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

206 elif key == '$defs': 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

207 schema['$defs'] = { 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

208 self.remap_defs_ref(DefsRef(key)): self.remap_json_schema(value) 

209 for key, value in schema['$defs'].items() 

210 } 

211 else: 

212 schema[key] = self.remap_json_schema(value) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

213 return schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

214 

215 

216class GenerateJsonSchema: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

217 """!!! abstract "Usage Documentation" 

218 [Customizing the JSON Schema Generation Process](../concepts/json_schema.md#customizing-the-json-schema-generation-process) 

219 

220 A class for generating JSON schemas. 

221 

222 This class generates JSON schemas based on configured parameters. The default schema dialect 

223 is [https://json-schema.org/draft/2020-12/schema](https://json-schema.org/draft/2020-12/schema). 

224 The class uses `by_alias` to configure how fields with 

225 multiple names are handled and `ref_template` to format reference names. 

226 

227 Attributes: 

228 schema_dialect: The JSON schema dialect used to generate the schema. See 

229 [Declaring a Dialect](https://json-schema.org/understanding-json-schema/reference/schema.html#id4) 

230 in the JSON Schema documentation for more information about dialects. 

231 ignored_warning_kinds: Warnings to ignore when generating the schema. `self.render_warning_message` will 

232 do nothing if its argument `kind` is in `ignored_warning_kinds`; 

233 this value can be modified on subclasses to easily control which warnings are emitted. 

234 by_alias: Whether to use field aliases when generating the schema. 

235 ref_template: The format string used when generating reference names. 

236 core_to_json_refs: A mapping of core refs to JSON refs. 

237 core_to_defs_refs: A mapping of core refs to definition refs. 

238 defs_to_core_refs: A mapping of definition refs to core refs. 

239 json_to_defs_refs: A mapping of JSON refs to definition refs. 

240 definitions: Definitions in the schema. 

241 

242 Args: 

243 by_alias: Whether to use field aliases in the generated schemas. 

244 ref_template: The format string to use when generating reference names. 

245 

246 Raises: 

247 JsonSchemaError: If the instance of the class is inadvertently reused after generating a schema. 

248 """ 

249 

250 schema_dialect = 'https://json-schema.org/draft/2020-12/schema' 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

251 

252 # `self.render_warning_message` will do nothing if its argument `kind` is in `ignored_warning_kinds`; 

253 # this value can be modified on subclasses to easily control which warnings are emitted 

254 ignored_warning_kinds: set[JsonSchemaWarningKind] = {'skipped-choice'} 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

255 

256 def __init__(self, by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE): 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

257 self.by_alias = by_alias 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

258 self.ref_template = ref_template 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

259 

260 self.core_to_json_refs: dict[CoreModeRef, JsonRef] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

261 self.core_to_defs_refs: dict[CoreModeRef, DefsRef] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

262 self.defs_to_core_refs: dict[DefsRef, CoreModeRef] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

263 self.json_to_defs_refs: dict[JsonRef, DefsRef] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

264 

265 self.definitions: dict[DefsRef, JsonSchemaValue] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

266 self._config_wrapper_stack = _config.ConfigWrapperStack(_config.ConfigWrapper({})) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

267 

268 self._mode: JsonSchemaMode = 'validation' 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

269 

270 # The following includes a mapping of a fully-unique defs ref choice to a list of preferred 

271 # alternatives, which are generally simpler, such as only including the class name. 

272 # At the end of schema generation, we use these to produce a JSON schema with more human-readable 

273 # definitions, which would also work better in a generated OpenAPI client, etc. 

274 self._prioritized_defsref_choices: dict[DefsRef, list[DefsRef]] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

275 self._collision_counter: dict[str, int] = defaultdict(int) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

276 self._collision_index: dict[str, int] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

277 

278 self._schema_type_to_method = self.build_schema_type_to_method() 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

279 

280 # When we encounter definitions we need to try to build them immediately 

281 # so that they are available schemas that reference them 

282 # But it's possible that CoreSchema was never going to be used 

283 # (e.g. because the CoreSchema that references short circuits is JSON schema generation without needing 

284 # the reference) so instead of failing altogether if we can't build a definition we 

285 # store the error raised and re-throw it if we end up needing that def 

286 self._core_defs_invalid_for_json_schema: dict[DefsRef, PydanticInvalidForJsonSchema] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

287 

288 # This changes to True after generating a schema, to prevent issues caused by accidental reuse 

289 # of a single instance of a schema generator 

290 self._used = False 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

291 

292 @property 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

293 def _config(self) -> _config.ConfigWrapper: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

294 return self._config_wrapper_stack.tail 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

295 

296 @property 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

297 def mode(self) -> JsonSchemaMode: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

298 if self._config.json_schema_mode_override is not None: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

299 return self._config.json_schema_mode_override 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

300 else: 

301 return self._mode 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

302 

303 def build_schema_type_to_method( 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

304 self, 

305 ) -> dict[CoreSchemaOrFieldType, Callable[[CoreSchemaOrField], JsonSchemaValue]]: 

306 """Builds a dictionary mapping fields to methods for generating JSON schemas. 

307 

308 Returns: 

309 A dictionary containing the mapping of `CoreSchemaOrFieldType` to a handler method. 

310 

311 Raises: 

312 TypeError: If no method has been defined for generating a JSON schema for a given pydantic core schema type. 

313 """ 

314 mapping: dict[CoreSchemaOrFieldType, Callable[[CoreSchemaOrField], JsonSchemaValue]] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

315 core_schema_types: list[CoreSchemaOrFieldType] = list(get_literal_values(CoreSchemaOrFieldType)) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

316 for key in core_schema_types: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

317 method_name = f'{key.replace("-", "_")}_schema' 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

318 try: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

319 mapping[key] = getattr(self, method_name) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

320 except AttributeError as e: # pragma: no cover 

321 if os.getenv('PYDANTIC_PRIVATE_ALLOW_UNHANDLED_SCHEMA_TYPES'): 

322 continue 

323 raise TypeError( 

324 f'No method for generating JsonSchema for core_schema.type={key!r} ' 

325 f'(expected: {type(self).__name__}.{method_name})' 

326 ) from e 

327 return mapping 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

328 

329 def generate_definitions( 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

330 self, inputs: Sequence[tuple[JsonSchemaKeyT, JsonSchemaMode, core_schema.CoreSchema]] 

331 ) -> tuple[dict[tuple[JsonSchemaKeyT, JsonSchemaMode], JsonSchemaValue], dict[DefsRef, JsonSchemaValue]]: 

332 """Generates JSON schema definitions from a list of core schemas, pairing the generated definitions with a 

333 mapping that links the input keys to the definition references. 

334 

335 Args: 

336 inputs: A sequence of tuples, where: 

337 

338 - The first element is a JSON schema key type. 

339 - The second element is the JSON mode: either 'validation' or 'serialization'. 

340 - The third element is a core schema. 

341 

342 Returns: 

343 A tuple where: 

344 

345 - The first element is a dictionary whose keys are tuples of JSON schema key type and JSON mode, and 

346 whose values are the JSON schema corresponding to that pair of inputs. (These schemas may have 

347 JsonRef references to definitions that are defined in the second returned element.) 

348 - The second element is a dictionary whose keys are definition references for the JSON schemas 

349 from the first returned element, and whose values are the actual JSON schema definitions. 

350 

351 Raises: 

352 PydanticUserError: Raised if the JSON schema generator has already been used to generate a JSON schema. 

353 """ 

354 if self._used: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

355 raise PydanticUserError( 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

356 'This JSON schema generator has already been used to generate a JSON schema. ' 

357 f'You must create a new instance of {type(self).__name__} to generate a new JSON schema.', 

358 code='json-schema-already-used', 

359 ) 

360 

361 for _, mode, schema in inputs: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

362 self._mode = mode 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

363 self.generate_inner(schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

364 

365 definitions_remapping = self._build_definitions_remapping() 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

366 

367 json_schemas_map: dict[tuple[JsonSchemaKeyT, JsonSchemaMode], DefsRef] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

368 for key, mode, schema in inputs: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

369 self._mode = mode 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

370 json_schema = self.generate_inner(schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

371 json_schemas_map[(key, mode)] = definitions_remapping.remap_json_schema(json_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

372 

373 json_schema = {'$defs': self.definitions} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

374 json_schema = definitions_remapping.remap_json_schema(json_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

375 self._used = True 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

376 return json_schemas_map, self.sort(json_schema['$defs']) # type: ignore 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

377 

378 def generate(self, schema: CoreSchema, mode: JsonSchemaMode = 'validation') -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

379 """Generates a JSON schema for a specified schema in a specified mode. 

380 

381 Args: 

382 schema: A Pydantic model. 

383 mode: The mode in which to generate the schema. Defaults to 'validation'. 

384 

385 Returns: 

386 A JSON schema representing the specified schema. 

387 

388 Raises: 

389 PydanticUserError: If the JSON schema generator has already been used to generate a JSON schema. 

390 """ 

391 self._mode = mode 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

392 if self._used: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

393 raise PydanticUserError( 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

394 'This JSON schema generator has already been used to generate a JSON schema. ' 

395 f'You must create a new instance of {type(self).__name__} to generate a new JSON schema.', 

396 code='json-schema-already-used', 

397 ) 

398 

399 json_schema: JsonSchemaValue = self.generate_inner(schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

400 json_ref_counts = self.get_json_ref_counts(json_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

401 

402 ref = cast(JsonRef, json_schema.get('$ref')) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

403 while ref is not None: # may need to unpack multiple levels 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

404 ref_json_schema = self.get_schema_from_definitions(ref) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

405 if json_ref_counts[ref] == 1 and ref_json_schema is not None and len(json_schema) == 1: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

406 # "Unpack" the ref since this is the only reference and there are no sibling keys 

407 json_schema = ref_json_schema.copy() # copy to prevent recursive dict reference 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

408 json_ref_counts[ref] -= 1 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

409 ref = cast(JsonRef, json_schema.get('$ref')) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

410 ref = None 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

411 

412 self._garbage_collect_definitions(json_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

413 definitions_remapping = self._build_definitions_remapping() 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

414 

415 if self.definitions: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

416 json_schema['$defs'] = self.definitions 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

417 

418 json_schema = definitions_remapping.remap_json_schema(json_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

419 

420 # For now, we will not set the $schema key. However, if desired, this can be easily added by overriding 

421 # this method and adding the following line after a call to super().generate(schema): 

422 # json_schema['$schema'] = self.schema_dialect 

423 

424 self._used = True 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

425 return self.sort(json_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

426 

427 def generate_inner(self, schema: CoreSchemaOrField) -> JsonSchemaValue: # noqa: C901 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

428 """Generates a JSON schema for a given core schema. 

429 

430 Args: 

431 schema: The given core schema. 

432 

433 Returns: 

434 The generated JSON schema. 

435 

436 TODO: the nested function definitions here seem like bad practice, I'd like to unpack these 

437 in a future PR. It'd be great if we could shorten the call stack a bit for JSON schema generation, 

438 and I think there's potential for that here. 

439 """ 

440 # If a schema with the same CoreRef has been handled, just return a reference to it 

441 # Note that this assumes that it will _never_ be the case that the same CoreRef is used 

442 # on types that should have different JSON schemas 

443 if 'ref' in schema: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

444 core_ref = CoreRef(schema['ref']) # type: ignore[typeddict-item] 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

445 core_mode_ref = (core_ref, self.mode) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

446 if core_mode_ref in self.core_to_defs_refs and self.core_to_defs_refs[core_mode_ref] in self.definitions: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

447 return {'$ref': self.core_to_json_refs[core_mode_ref]} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

448 

449 def populate_defs(core_schema: CoreSchema, json_schema: JsonSchemaValue) -> JsonSchemaValue: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

450 if 'ref' in core_schema: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

451 core_ref = CoreRef(core_schema['ref']) # type: ignore[typeddict-item] 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

452 defs_ref, ref_json_schema = self.get_cache_defs_ref_schema(core_ref) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

453 json_ref = JsonRef(ref_json_schema['$ref']) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

454 # Replace the schema if it's not a reference to itself 

455 # What we want to avoid is having the def be just a ref to itself 

456 # which is what would happen if we blindly assigned any 

457 if json_schema.get('$ref', None) != json_ref: 457 ↛ 460line 457 didn't jump to line 460 because the condition on line 457 was always true35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

458 self.definitions[defs_ref] = json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

459 self._core_defs_invalid_for_json_schema.pop(defs_ref, None) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

460 json_schema = ref_json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

461 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

462 

463 def handler_func(schema_or_field: CoreSchemaOrField) -> JsonSchemaValue: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

464 """Generate a JSON schema based on the input schema. 

465 

466 Args: 

467 schema_or_field: The core schema to generate a JSON schema from. 

468 

469 Returns: 

470 The generated JSON schema. 

471 

472 Raises: 

473 TypeError: If an unexpected schema type is encountered. 

474 """ 

475 # Generate the core-schema-type-specific bits of the schema generation: 

476 json_schema: JsonSchemaValue | None = None 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

477 if self.mode == 'serialization' and 'serialization' in schema_or_field: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

478 # In this case, we skip the JSON Schema generation of the schema 

479 # and use the `'serialization'` schema instead (canonical example: 

480 # `Annotated[int, PlainSerializer(str)]`). 

481 ser_schema = schema_or_field['serialization'] # type: ignore 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

482 json_schema = self.ser_schema(ser_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

483 

484 # It might be that the 'serialization'` is skipped depending on `when_used`. 

485 # This is only relevant for `nullable` schemas though, so we special case here. 

486 if ( 4 ctx1CDEa

487 json_schema is not None 

488 and ser_schema.get('when_used') in ('unless-none', 'json-unless-none') 

489 and schema_or_field['type'] == 'nullable' 

490 ): 

491 json_schema = self.get_flattened_anyof([{'type': 'null'}, json_schema]) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

492 if json_schema is None: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

493 if _core_utils.is_core_schema(schema_or_field) or _core_utils.is_core_schema_field(schema_or_field): 493 ↛ 497line 493 didn't jump to line 497 because the condition on line 493 was always true35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

494 generate_for_schema_type = self._schema_type_to_method[schema_or_field['type']] 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

495 json_schema = generate_for_schema_type(schema_or_field) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

496 else: 

497 raise TypeError(f'Unexpected schema type: schema={schema_or_field}') 

498 

499 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

500 

501 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, handler_func) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

502 

503 metadata = cast(_core_metadata.CoreMetadata, schema.get('metadata', {})) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

504 

505 # TODO: I dislike that we have to wrap these basic dict updates in callables, is there any way around this? 

506 

507 if js_updates := metadata.get('pydantic_js_updates'): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

508 

509 def js_updates_handler_func( 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

510 schema_or_field: CoreSchemaOrField, 

511 current_handler: GetJsonSchemaHandler = current_handler, 

512 ) -> JsonSchemaValue: 

513 json_schema = {**current_handler(schema_or_field), **js_updates} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

514 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

515 

516 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, js_updates_handler_func) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

517 

518 if js_extra := metadata.get('pydantic_js_extra'): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

519 

520 def js_extra_handler_func( 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

521 schema_or_field: CoreSchemaOrField, 

522 current_handler: GetJsonSchemaHandler = current_handler, 

523 ) -> JsonSchemaValue: 

524 json_schema = current_handler(schema_or_field) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

525 if isinstance(js_extra, dict): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

526 json_schema.update(to_jsonable_python(js_extra)) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

527 elif callable(js_extra): 527 ↛ 530line 527 didn't jump to line 530 because the condition on line 527 was always true35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

528 # similar to typing issue in _update_class_schema when we're working with callable js extra 

529 js_extra(json_schema) # type: ignore 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

530 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

531 

532 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, js_extra_handler_func) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

533 

534 for js_modify_function in metadata.get('pydantic_js_functions', ()): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

535 

536 def new_handler_func( 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

537 schema_or_field: CoreSchemaOrField, 

538 current_handler: GetJsonSchemaHandler = current_handler, 

539 js_modify_function: GetJsonSchemaFunction = js_modify_function, 

540 ) -> JsonSchemaValue: 

541 json_schema = js_modify_function(schema_or_field, current_handler) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

542 if _core_utils.is_core_schema(schema_or_field): 542 ↛ 544line 542 didn't jump to line 544 because the condition on line 542 was always true35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

543 json_schema = populate_defs(schema_or_field, json_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

544 original_schema = current_handler.resolve_ref_schema(json_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

545 ref = json_schema.pop('$ref', None) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

546 if ref and json_schema: 546 ↛ 547line 546 didn't jump to line 547 because the condition on line 546 was never true35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

547 original_schema.update(json_schema) 

548 return original_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

549 

550 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, new_handler_func) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

551 

552 for js_modify_function in metadata.get('pydantic_js_annotation_functions', ()): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

553 

554 def new_handler_func( 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

555 schema_or_field: CoreSchemaOrField, 

556 current_handler: GetJsonSchemaHandler = current_handler, 

557 js_modify_function: GetJsonSchemaFunction = js_modify_function, 

558 ) -> JsonSchemaValue: 

559 return js_modify_function(schema_or_field, current_handler) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

560 

561 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, new_handler_func) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

562 

563 json_schema = current_handler(schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

564 if _core_utils.is_core_schema(schema): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

565 json_schema = populate_defs(schema, json_schema) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

566 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

567 

568 def sort(self, value: JsonSchemaValue, parent_key: str | None = None) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

569 """Override this method to customize the sorting of the JSON schema (e.g., don't sort at all, sort all keys unconditionally, etc.) 

570 

571 By default, alphabetically sort the keys in the JSON schema, skipping the 'properties' and 'default' keys to preserve field definition order. 

572 This sort is recursive, so it will sort all nested dictionaries as well. 

573 """ 

574 sorted_dict: dict[str, JsonSchemaValue] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

575 keys = value.keys() 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

576 if parent_key not in ('properties', 'default'): 576 ↛ 578line 576 didn't jump to line 578 because the condition on line 576 was always true35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

577 keys = sorted(keys) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

578 for key in keys: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

579 sorted_dict[key] = self._sort_recursive(value[key], parent_key=key) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

580 return sorted_dict 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

581 

582 def _sort_recursive(self, value: Any, parent_key: str | None = None) -> Any: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

583 """Recursively sort a JSON schema value.""" 

584 if isinstance(value, dict): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

585 sorted_dict: dict[str, JsonSchemaValue] = {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

586 keys = value.keys() 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

587 if parent_key not in ('properties', 'default'): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

588 keys = sorted(keys) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

589 for key in keys: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

590 sorted_dict[key] = self._sort_recursive(value[key], parent_key=key) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

591 return sorted_dict 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

592 elif isinstance(value, list): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

593 sorted_list: list[JsonSchemaValue] = [] 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

594 for item in value: 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

595 sorted_list.append(self._sort_recursive(item, parent_key)) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

596 return sorted_list 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

597 else: 

598 return value 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

599 

600 # ### Schema generation methods 

601 

602 def invalid_schema(self, schema: core_schema.InvalidSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

603 """Placeholder - should never be called.""" 

604 

605 raise RuntimeError('Cannot generate schema for invalid_schema. This is a bug! Please report it.') 

606 

607 def any_schema(self, schema: core_schema.AnySchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

608 """Generates a JSON schema that matches any value. 

609 

610 Args: 

611 schema: The core schema. 

612 

613 Returns: 

614 The generated JSON schema. 

615 """ 

616 return {} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

617 

618 def none_schema(self, schema: core_schema.NoneSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

619 """Generates a JSON schema that matches `None`. 

620 

621 Args: 

622 schema: The core schema. 

623 

624 Returns: 

625 The generated JSON schema. 

626 """ 

627 return {'type': 'null'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

628 

629 def bool_schema(self, schema: core_schema.BoolSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

630 """Generates a JSON schema that matches a bool value. 

631 

632 Args: 

633 schema: The core schema. 

634 

635 Returns: 

636 The generated JSON schema. 

637 """ 

638 return {'type': 'boolean'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

639 

640 def int_schema(self, schema: core_schema.IntSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

641 """Generates a JSON schema that matches an int value. 

642 

643 Args: 

644 schema: The core schema. 

645 

646 Returns: 

647 The generated JSON schema. 

648 """ 

649 json_schema: dict[str, Any] = {'type': 'integer'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

650 self.update_with_validations(json_schema, schema, self.ValidationsMapping.numeric) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

651 json_schema = {k: v for k, v in json_schema.items() if v not in {math.inf, -math.inf}} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

652 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

653 

654 def float_schema(self, schema: core_schema.FloatSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

655 """Generates a JSON schema that matches a float value. 

656 

657 Args: 

658 schema: The core schema. 

659 

660 Returns: 

661 The generated JSON schema. 

662 """ 

663 json_schema: dict[str, Any] = {'type': 'number'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

664 self.update_with_validations(json_schema, schema, self.ValidationsMapping.numeric) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

665 json_schema = {k: v for k, v in json_schema.items() if v not in {math.inf, -math.inf}} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

666 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

667 

668 def decimal_schema(self, schema: core_schema.DecimalSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

669 """Generates a JSON schema that matches a decimal value. 

670 

671 Args: 

672 schema: The core schema. 

673 

674 Returns: 

675 The generated JSON schema. 

676 """ 

677 json_schema = self.str_schema(core_schema.str_schema()) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

678 if self.mode == 'validation': 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

679 multiple_of = schema.get('multiple_of') 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

680 le = schema.get('le') 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

681 ge = schema.get('ge') 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

682 lt = schema.get('lt') 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

683 gt = schema.get('gt') 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

684 json_schema = { 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

685 'anyOf': [ 

686 self.float_schema( 

687 core_schema.float_schema( 

688 allow_inf_nan=schema.get('allow_inf_nan'), 

689 multiple_of=None if multiple_of is None else float(multiple_of), 

690 le=None if le is None else float(le), 

691 ge=None if ge is None else float(ge), 

692 lt=None if lt is None else float(lt), 

693 gt=None if gt is None else float(gt), 

694 ) 

695 ), 

696 json_schema, 

697 ], 

698 } 

699 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

700 

701 def str_schema(self, schema: core_schema.StringSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

702 """Generates a JSON schema that matches a string value. 

703 

704 Args: 

705 schema: The core schema. 

706 

707 Returns: 

708 The generated JSON schema. 

709 """ 

710 json_schema = {'type': 'string'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

711 self.update_with_validations(json_schema, schema, self.ValidationsMapping.string) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

712 if isinstance(json_schema.get('pattern'), Pattern): 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

713 # TODO: should we add regex flags to the pattern? 

714 json_schema['pattern'] = json_schema.get('pattern').pattern # type: ignore 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

715 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

716 

717 def bytes_schema(self, schema: core_schema.BytesSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

718 """Generates a JSON schema that matches a bytes value. 

719 

720 Args: 

721 schema: The core schema. 

722 

723 Returns: 

724 The generated JSON schema. 

725 """ 

726 json_schema = {'type': 'string', 'format': 'base64url' if self._config.ser_json_bytes == 'base64' else 'binary'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

727 self.update_with_validations(json_schema, schema, self.ValidationsMapping.bytes) 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

728 return json_schema 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

729 

730 def date_schema(self, schema: core_schema.DateSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

731 """Generates a JSON schema that matches a date value. 

732 

733 Args: 

734 schema: The core schema. 

735 

736 Returns: 

737 The generated JSON schema. 

738 """ 

739 return {'type': 'string', 'format': 'date'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

740 

741 def time_schema(self, schema: core_schema.TimeSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

742 """Generates a JSON schema that matches a time value. 

743 

744 Args: 

745 schema: The core schema. 

746 

747 Returns: 

748 The generated JSON schema. 

749 """ 

750 return {'type': 'string', 'format': 'time'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

751 

752 def datetime_schema(self, schema: core_schema.DatetimeSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

753 """Generates a JSON schema that matches a datetime value. 

754 

755 Args: 

756 schema: The core schema. 

757 

758 Returns: 

759 The generated JSON schema. 

760 """ 

761 return {'type': 'string', 'format': 'date-time'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

762 

763 def timedelta_schema(self, schema: core_schema.TimedeltaSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx

764 """Generates a JSON schema that matches a timedelta value. 

765 

766 Args: 

767 schema: The core schema. 

768 

769 Returns: 

770 The generated JSON schema. 

771 """ 

772 if self._config.ser_json_timedelta == 'float': 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

773 return {'type': 'number'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

774 return {'type': 'string', 'format': 'duration'} 35 ctx1CDbhiycjdklEaGHmnzAopqrsFIetuBfvgwx

775 

776 def literal_schema(self, schema: core_schema.LiteralSchema) -> JsonSchemaValue: 42 ctx1CDbhiycjdklEaGHmnzAopqrsPNOJKLMFIetuBfvgwx