Coverage for pydantic/json_schema.py: 94.66%

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

13 

14import dataclasses 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

15import inspect 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

16import math 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

17import os 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

18import re 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

19import warnings 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

20from collections import Counter, defaultdict 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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

22from copy import deepcopy 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

23from enum import Enum 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

24from re import Pattern 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

25from typing import ( 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

39from pydantic_core import MISSING, CoreSchema, PydanticOmit, core_schema, to_jsonable_python 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

40from pydantic_core.core_schema import ComputedField 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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

42from typing_inspection.introspection import get_literal_values 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

43 

44from pydantic.warnings import PydanticDeprecatedSince26, PydanticDeprecatedSince29 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

45 

46from ._internal import ( 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

56from .config import JsonDict, JsonValue 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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

58 

59if TYPE_CHECKING: 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

68""" 35 ctx1bdenfogpADEahiqrstuvGHIPcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

75""" 35 ctx1bdenfogpADEahiqrstuvGHIPcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

80""" 35 ctx1bdenfogpADEahiqrstuvGHIPcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

90 

91 

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

93""" 35 ctx1bdenfogpADEahiqrstuvGHIPcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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

111for a core schema with a default value. 

112""" 

113 

114 

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

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

117"""The default format string used to generate reference names.""" 35 ctx1bdenfogpADEahiqrstuvGHIPcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

130 

131CoreModeRef = tuple[CoreRef, JsonSchemaMode] 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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

133 

134 

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

136class _DefinitionsRemapping: 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

137 defs_remapping: dict[DefsRef, DefsRef] 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

138 json_remapping: dict[JsonRef, JsonRef] 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

139 

140 @staticmethod 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

141 def from_prioritized_choices( 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

155 definitions_schema = {'$defs': copied_definitions} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 complete41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

159 for defs_ref in copied_definitions: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

160 alternatives = prioritized_choices[defs_ref] 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

161 for alternative in alternatives: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

162 schemas_for_alternatives[alternative].append(copied_definitions[defs_ref]) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

167 schemas_for_alternatives[defs_ref] = _deduplicate_schemas(schemas_for_alternatives[defs_ref]) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

168 

169 # Build the remapping 

170 defs_remapping: dict[DefsRef, DefsRef] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

171 json_remapping: dict[JsonRef, JsonRef] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

172 for original_defs_ref in definitions: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

173 alternatives = prioritized_choices[original_defs_ref] 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

176 defs_remapping[original_defs_ref] = remapped_defs_ref 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

177 json_remapping[defs_to_json[original_defs_ref]] = defs_to_json[remapped_defs_ref] 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

178 remapping = _DefinitionsRemapping(defs_remapping, json_remapping) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

179 new_definitions_schema = remapping.remap_json_schema({'$defs': copied_definitions}) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

180 if definitions_schema == new_definitions_schema: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

181 # We've reached the fixed point 

182 return remapping 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

183 definitions_schema = new_definitions_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

184 

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

186 

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

188 return self.defs_remapping.get(ref, ref) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

189 

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

191 return self.json_remapping.get(ref, ref) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

192 

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

194 """ 

195 Recursively update the JSON schema replacing all $refs 

196 """ 

197 if isinstance(schema, str): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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)) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

200 elif isinstance(schema, list): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

201 return [self.remap_json_schema(item) for item in schema] 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

202 elif isinstance(schema, dict): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

203 for key, value in schema.items(): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

204 if key == '$ref' and isinstance(value, str): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

205 schema['$ref'] = self.remap_json_ref(JsonRef(value)) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

206 elif key == '$defs': 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

207 schema['$defs'] = { 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

213 return schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

214 

215 

216class GenerateJsonSchema: 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

255 

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

257 self.by_alias = by_alias 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

258 self.ref_template = ref_template 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

259 

260 self.core_to_json_refs: dict[CoreModeRef, JsonRef] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

261 self.core_to_defs_refs: dict[CoreModeRef, DefsRef] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

262 self.defs_to_core_refs: dict[DefsRef, CoreModeRef] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

263 self.json_to_defs_refs: dict[JsonRef, DefsRef] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

264 

265 self.definitions: dict[DefsRef, JsonSchemaValue] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

266 self._config_wrapper_stack = _config.ConfigWrapperStack(_config.ConfigWrapper({})) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

267 

268 self._mode: JsonSchemaMode = 'validation' 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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]] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

275 self._collision_counter: dict[str, int] = defaultdict(int) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

276 self._collision_index: dict[str, int] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

277 

278 self._schema_type_to_method = self.build_schema_type_to_method() 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

291 

292 @property 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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

294 return self._config_wrapper_stack.tail 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

295 

296 @property 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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

298 if self._config.json_schema_mode_override is not None: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

299 return self._config.json_schema_mode_override 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

300 else: 

301 return self._mode 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

302 

303 def build_schema_type_to_method( 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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]] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

315 core_schema_types: list[CoreSchemaOrFieldType] = list(get_literal_values(CoreSchemaOrFieldType)) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

316 for key in core_schema_types: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

318 try: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

319 mapping[key] = getattr(self, method_name) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

328 

329 def generate_definitions( 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

355 raise PydanticUserError( 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

362 self._mode = mode 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

363 self.generate_inner(schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

364 

365 definitions_remapping = self._build_definitions_remapping() 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

366 

367 json_schemas_map: dict[tuple[JsonSchemaKeyT, JsonSchemaMode], DefsRef] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

368 for key, mode, schema in inputs: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

369 self._mode = mode 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

370 json_schema = self.generate_inner(schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

371 json_schemas_map[(key, mode)] = definitions_remapping.remap_json_schema(json_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

372 

373 json_schema = {'$defs': self.definitions} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

374 json_schema = definitions_remapping.remap_json_schema(json_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

375 self._used = True 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

377 

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

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 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

392 if self._used: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

393 raise PydanticUserError( 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

400 json_ref_counts = self.get_json_ref_counts(json_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

401 

402 ref = cast(JsonRef, json_schema.get('$ref')) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

403 while ref is not None: # may need to unpack multiple levels 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

404 ref_json_schema = self.get_schema_from_definitions(ref) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

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 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

408 json_ref_counts[ref] -= 1 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

409 ref = cast(JsonRef, json_schema.get('$ref')) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

410 ref = None 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

411 

412 self._garbage_collect_definitions(json_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

413 definitions_remapping = self._build_definitions_remapping() 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

414 

415 if self.definitions: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

416 json_schema['$defs'] = self.definitions 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

417 

418 json_schema = definitions_remapping.remap_json_schema(json_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

425 return self.sort(json_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

426 

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

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: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

445 core_mode_ref = (core_ref, self.mode) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

446 if core_mode_ref in self.core_to_defs_refs and self.core_to_defs_refs[core_mode_ref] in self.definitions: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

447 return {'$ref': self.core_to_json_refs[core_mode_ref]} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

448 

449 def populate_defs(core_schema: CoreSchema, json_schema: JsonSchemaValue) -> JsonSchemaValue: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

450 if 'ref' in core_schema: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

452 defs_ref, ref_json_schema = self.get_cache_defs_ref_schema(core_ref) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

453 json_ref = JsonRef(ref_json_schema['$ref']) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 true41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

458 self.definitions[defs_ref] = json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

459 self._core_defs_invalid_for_json_schema.pop(defs_ref, None) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

460 json_schema = ref_json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

461 return json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

462 

463 def handler_func(schema_or_field: CoreSchemaOrField) -> JsonSchemaValue: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

477 if self.mode == 'serialization' and 'serialization' in schema_or_field: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

482 json_schema = self.ser_schema(ser_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 ctx1zCFa

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]) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

492 if json_schema is None: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 true41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

494 generate_for_schema_type = self._schema_type_to_method[schema_or_field['type']] 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

495 json_schema = generate_for_schema_type(schema_or_field) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

496 else: 

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

498 

499 return json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

500 

501 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, handler_func) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

502 

503 metadata = cast(_core_metadata.CoreMetadata, schema.get('metadata', {})) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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'): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

508 

509 def js_updates_handler_func( 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

510 schema_or_field: CoreSchemaOrField, 

511 current_handler: GetJsonSchemaHandler = current_handler, 

512 ) -> JsonSchemaValue: 

513 json_schema = {**current_handler(schema_or_field), **js_updates} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

514 return json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

515 

516 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, js_updates_handler_func) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

517 

518 if js_extra := metadata.get('pydantic_js_extra'): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

519 

520 def js_extra_handler_func( 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

521 schema_or_field: CoreSchemaOrField, 

522 current_handler: GetJsonSchemaHandler = current_handler, 

523 ) -> JsonSchemaValue: 

524 json_schema = current_handler(schema_or_field) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

525 if isinstance(js_extra, dict): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

526 json_schema.update(to_jsonable_python(js_extra)) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

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

529 js_extra(json_schema) # type: ignore 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

530 return json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

531 

532 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, js_extra_handler_func) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

533 

534 for js_modify_function in metadata.get('pydantic_js_functions', ()): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

535 

536 def new_handler_func( 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 true41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

543 json_schema = populate_defs(schema_or_field, json_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

544 original_schema = current_handler.resolve_ref_schema(json_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

545 ref = json_schema.pop('$ref', None) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

547 original_schema.update(json_schema) 

548 return original_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

549 

550 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, new_handler_func) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

551 

552 for js_modify_function in metadata.get('pydantic_js_annotation_functions', ()): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

553 

554 def new_handler_func( 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

560 

561 current_handler = _schema_generation_shared.GenerateJsonSchemaHandler(self, new_handler_func) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

562 

563 json_schema = current_handler(schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

564 if _core_utils.is_core_schema(schema): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

565 json_schema = populate_defs(schema, json_schema) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

566 return json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

567 

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

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] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

575 keys = value.keys() 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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 true41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

577 keys = sorted(keys) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

578 for key in keys: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

579 sorted_dict[key] = self._sort_recursive(value[key], parent_key=key) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

580 return sorted_dict 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

581 

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

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

584 if isinstance(value, dict): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

585 sorted_dict: dict[str, JsonSchemaValue] = {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

586 keys = value.keys() 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

587 if parent_key not in ('properties', 'default'): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

588 keys = sorted(keys) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

589 for key in keys: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

590 sorted_dict[key] = self._sort_recursive(value[key], parent_key=key) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

591 return sorted_dict 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

592 elif isinstance(value, list): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

593 sorted_list: list[JsonSchemaValue] = [] 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

594 for item in value: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

595 sorted_list.append(self._sort_recursive(item, parent_key)) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

596 return sorted_list 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

597 else: 

598 return value 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

599 

600 # ### Schema generation methods 

601 

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

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 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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 {} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

617 

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

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'} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

628 

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

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'} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

639 

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

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'} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

650 self.update_with_validations(json_schema, schema, self.ValidationsMapping.numeric) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

652 return json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

653 

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

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'} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

664 self.update_with_validations(json_schema, schema, self.ValidationsMapping.numeric) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

666 return json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

667 

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

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 

678 def get_decimal_pattern(schema: core_schema.DecimalSchema) -> str: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

679 max_digits = schema.get('max_digits') 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

680 decimal_places = schema.get('decimal_places') 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

681 

682 pattern = ( 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

683 r'^(?!^[-+.]*$)[+-]?0*' # check it is not empty string and not one or sequence of ".+-" characters. 

684 ) 

685 

686 # Case 1: Both max_digits and decimal_places are set 

687 if max_digits is not None and decimal_places is not None: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

688 integer_places = max(0, max_digits - decimal_places) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

689 pattern += ( 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

690 rf'(?:' 

691 rf'\d{{0,{integer_places}}}' 

692 rf'|' 

693 rf'(?=[\d.]{{1,{max_digits + 1}}}0*$)' 

694 rf'\d{{0,{integer_places}}}\.\d{{0,{decimal_places}}}0*$' 

695 rf')' 

696 ) 

697 

698 # Case 2: Only max_digits is set 

699 elif max_digits is not None and decimal_places is None: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

700 pattern += ( 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

701 rf'(?:' 

702 rf'\d{{0,{max_digits}}}' 

703 rf'|' 

704 rf'(?=[\d.]{{1,{max_digits + 1}}}0*$)' 

705 rf'\d*\.\d*0*$' 

706 rf')' 

707 ) 

708 

709 # Case 3: Only decimal_places is set 

710 elif max_digits is None and decimal_places is not None: 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

711 pattern += rf'\d*\.?\d{{0,{decimal_places}}}0*$' 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

712 

713 # Case 4: Both are None (no restrictions) 

714 else: 

715 pattern += r'\d*\.?\d*$' # look for arbitrary integer or decimal 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

716 

717 return pattern 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

718 

719 json_schema = self.str_schema(core_schema.str_schema(pattern=get_decimal_pattern(schema))) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

720 if self.mode == 'validation': 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

721 multiple_of = schema.get('multiple_of') 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

722 le = schema.get('le') 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

723 ge = schema.get('ge') 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

724 lt = schema.get('lt') 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

725 gt = schema.get('gt') 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

726 json_schema = { 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

727 'anyOf': [ 

728 self.float_schema( 

729 core_schema.float_schema( 

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

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

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

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

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

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

736 ) 

737 ), 

738 json_schema, 

739 ], 

740 } 

741 return json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

742 

743 def str_schema(self, schema: core_schema.StringSchema) -> JsonSchemaValue: 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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

745 

746 Args: 

747 schema: The core schema. 

748 

749 Returns: 

750 The generated JSON schema. 

751 """ 

752 json_schema = {'type': 'string'} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

753 self.update_with_validations(json_schema, schema, self.ValidationsMapping.string) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

754 if isinstance(json_schema.get('pattern'), Pattern): 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

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

756 json_schema['pattern'] = json_schema.get('pattern').pattern # type: ignore 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

757 return json_schema 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

758 

759 def bytes_schema(self, schema: core_schema.BytesSchema) -> JsonSchemaValue: 42 ctx1zCbdenfogpADEFaMNhiqrstuvGHIPLOcjkwlxmyBJK

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

761 

762 Args: 

763 schema: The core schema. 

764 

765 Returns: 

766 The generated JSON schema. 

767 """ 

768 json_schema = {'type': 'string', 'format': 'base64url' if self._config.ser_json_bytes == 'base64' else 'binary'} 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK

769 self.update_with_validations(json_schema, schema, self.ValidationsMapping.bytes) 41 ctx1zCbdenfogpADEFaMNhiqrstuvGHILOcjkwlxmyBJK