Coverage for pydantic/_internal/_validators.py: 99.45%

1"""Validator functions for standard library types. 

2 

3Import of this module is deferred since it contains imports of many standard library modules. 

4""" 

5 

6from __future__ import annotations as _annotations 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

7 

8import collections.abc 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

9import math 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

10import re 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

11import typing 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

12from decimal import Decimal 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

13from fractions import Fraction 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

14from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address, IPv6Interface, IPv6Network 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

15from typing import Any, Callable, Union, cast, get_origin 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

16from zoneinfo import ZoneInfo, ZoneInfoNotFoundError 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

17 

18import typing_extensions 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

19from pydantic_core import PydanticCustomError, core_schema 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

20from pydantic_core._pydantic_core import PydanticKnownError 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

21from typing_inspection import typing_objects 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

22 

23from pydantic._internal._import_utils import import_cached_field_info 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

24from pydantic.errors import PydanticSchemaGenerationError 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

25 

26 

27def sequence_validator( 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

28 input_value: typing.Sequence[Any], 

29 /, 

30 validator: core_schema.ValidatorFunctionWrapHandler, 

31) -> typing.Sequence[Any]: 

32 """Validator for `Sequence` types, isinstance(v, Sequence) has already been called.""" 

33 value_type = type(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

34 

35 # We don't accept any plain string as a sequence 

36 # Relevant issue: https://github.com/pydantic/pydantic/issues/5595 

37 if issubclass(value_type, (str, bytes)): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

38 raise PydanticCustomError( 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

39 'sequence_str', 

40 "'{type_name}' instances are not allowed as a Sequence value", 

41 {'type_name': value_type.__name__}, 

42 ) 

43 

44 # TODO: refactor sequence validation to validate with either a list or a tuple 

45 # schema, depending on the type of the value. 

46 # Additionally, we should be able to remove one of either this validator or the 

47 # SequenceValidator in _std_types_schema.py (preferably this one, while porting over some logic). 

48 # Effectively, a refactor for sequence validation is needed. 

49 if value_type is tuple: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

50 input_value = list(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

51 

52 v_list = validator(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

53 

54 # the rest of the logic is just re-creating the original type from `v_list` 

55 if value_type is list: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

56 return v_list 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

57 elif issubclass(value_type, range): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

58 # return the list as we probably can't re-create the range 

59 return v_list 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

60 elif value_type is tuple: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

61 return tuple(v_list) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

62 else: 

63 # best guess at how to re-create the original type, more custom construction logic might be required 

64 return value_type(v_list) # type: ignore[call-arg] 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

65 

66 

67def import_string(value: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

68 if isinstance(value, str): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

69 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

70 return _import_string_logic(value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

71 except ImportError as e: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

72 raise PydanticCustomError('import_error', 'Invalid python path: {error}', {'error': str(e)}) from e 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

73 else: 

74 # otherwise we just return the value and let the next validator do the rest of the work 

75 return value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

76 

77 

78def _import_string_logic(dotted_path: str) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

79 """Inspired by uvicorn — dotted paths should include a colon before the final item if that item is not a module. 

80 (This is necessary to distinguish between a submodule and an attribute when there is a conflict.). 

81 

82 If the dotted path does not include a colon and the final item is not a valid module, importing as an attribute 

83 rather than a submodule will be attempted automatically. 

84 

85 So, for example, the following values of `dotted_path` result in the following returned values: 

86 * 'collections': <module 'collections'> 

87 * 'collections.abc': <module 'collections.abc'> 

88 * 'collections.abc:Mapping': <class 'collections.abc.Mapping'> 

89 * `collections.abc.Mapping`: <class 'collections.abc.Mapping'> (though this is a bit slower than the previous line) 

90 

91 An error will be raised under any of the following scenarios: 

92 * `dotted_path` contains more than one colon (e.g., 'collections:abc:Mapping') 

93 * the substring of `dotted_path` before the colon is not a valid module in the environment (e.g., '123:Mapping') 

94 * the substring of `dotted_path` after the colon is not an attribute of the module (e.g., 'collections:abc123') 

95 """ 

96 from importlib import import_module 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

97 

98 components = dotted_path.strip().split(':') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

99 if len(components) > 2: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

100 raise ImportError(f"Import strings should have at most one ':'; received {dotted_path!r}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

101 

102 module_path = components[0] 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

103 if not module_path: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

104 raise ImportError(f'Import strings should have a nonempty module name; received {dotted_path!r}') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

105 

106 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

107 module = import_module(module_path) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

108 except ModuleNotFoundError as e: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

109 if '.' in module_path: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

110 # Check if it would be valid if the final item was separated from its module with a `:` 

111 maybe_module_path, maybe_attribute = dotted_path.strip().rsplit('.', 1) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

112 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

113 return _import_string_logic(f'{maybe_module_path}:{maybe_attribute}') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

114 except ImportError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

115 pass 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

116 raise ImportError(f'No module named {module_path!r}') from e 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

117 raise e 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

118 

119 if len(components) > 1: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

120 attribute = components[1] 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

121 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

122 return getattr(module, attribute) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

123 except AttributeError as e: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

124 raise ImportError(f'cannot import name {attribute!r} from {module_path!r}') from e 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

125 else: 

126 return module 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

127 

128 

129def pattern_either_validator(input_value: Any, /) -> typing.Pattern[Any]: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

130 if isinstance(input_value, typing.Pattern): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

131 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

132 elif isinstance(input_value, (str, bytes)): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

133 # todo strict mode 

134 return compile_pattern(input_value) # type: ignore 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

135 else: 

136 raise PydanticCustomError('pattern_type', 'Input should be a valid pattern') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

137 

138 

139def pattern_str_validator(input_value: Any, /) -> typing.Pattern[str]: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

140 if isinstance(input_value, typing.Pattern): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

141 if isinstance(input_value.pattern, str): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

142 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

143 else: 

144 raise PydanticCustomError('pattern_str_type', 'Input should be a string pattern') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

145 elif isinstance(input_value, str): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

146 return compile_pattern(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

147 elif isinstance(input_value, bytes): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

148 raise PydanticCustomError('pattern_str_type', 'Input should be a string pattern') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

149 else: 

150 raise PydanticCustomError('pattern_type', 'Input should be a valid pattern') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

151 

152 

153def pattern_bytes_validator(input_value: Any, /) -> typing.Pattern[bytes]: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

154 if isinstance(input_value, typing.Pattern): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

155 if isinstance(input_value.pattern, bytes): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

156 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

157 else: 

158 raise PydanticCustomError('pattern_bytes_type', 'Input should be a bytes pattern') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

159 elif isinstance(input_value, bytes): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

160 return compile_pattern(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

161 elif isinstance(input_value, str): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

162 raise PydanticCustomError('pattern_bytes_type', 'Input should be a bytes pattern') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

163 else: 

164 raise PydanticCustomError('pattern_type', 'Input should be a valid pattern') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

165 

166 

167PatternType = typing.TypeVar('PatternType', str, bytes) 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

168 

169 

170def compile_pattern(pattern: PatternType) -> typing.Pattern[PatternType]: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

171 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

172 return re.compile(pattern) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

173 except re.error: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

174 raise PydanticCustomError('pattern_regex', 'Input should be a valid regular expression') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

175 

176 

177def ip_v4_address_validator(input_value: Any, /) -> IPv4Address: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

178 if isinstance(input_value, IPv4Address): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

179 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

180 

181 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

182 return IPv4Address(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

183 except ValueError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

184 raise PydanticCustomError('ip_v4_address', 'Input is not a valid IPv4 address') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

185 

186 

187def ip_v6_address_validator(input_value: Any, /) -> IPv6Address: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

188 if isinstance(input_value, IPv6Address): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

189 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

190 

191 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

192 return IPv6Address(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

193 except ValueError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

194 raise PydanticCustomError('ip_v6_address', 'Input is not a valid IPv6 address') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

195 

196 

197def ip_v4_network_validator(input_value: Any, /) -> IPv4Network: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

198 """Assume IPv4Network initialised with a default `strict` argument. 

199 

200 See more: 

201 https://docs.python.org/library/ipaddress.html#ipaddress.IPv4Network 

202 """ 

203 if isinstance(input_value, IPv4Network): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

204 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

205 

206 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

207 return IPv4Network(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

208 except ValueError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

209 raise PydanticCustomError('ip_v4_network', 'Input is not a valid IPv4 network') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

210 

211 

212def ip_v6_network_validator(input_value: Any, /) -> IPv6Network: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

213 """Assume IPv6Network initialised with a default `strict` argument. 

214 

215 See more: 

216 https://docs.python.org/library/ipaddress.html#ipaddress.IPv6Network 

217 """ 

218 if isinstance(input_value, IPv6Network): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

219 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

220 

221 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

222 return IPv6Network(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

223 except ValueError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

224 raise PydanticCustomError('ip_v6_network', 'Input is not a valid IPv6 network') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

225 

226 

227def ip_v4_interface_validator(input_value: Any, /) -> IPv4Interface: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

228 if isinstance(input_value, IPv4Interface): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

229 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

230 

231 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

232 return IPv4Interface(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

233 except ValueError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

234 raise PydanticCustomError('ip_v4_interface', 'Input is not a valid IPv4 interface') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

235 

236 

237def ip_v6_interface_validator(input_value: Any, /) -> IPv6Interface: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

238 if isinstance(input_value, IPv6Interface): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

239 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

240 

241 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

242 return IPv6Interface(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

243 except ValueError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

244 raise PydanticCustomError('ip_v6_interface', 'Input is not a valid IPv6 interface') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

245 

246 

247def fraction_validator(input_value: Any, /) -> Fraction: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

248 if isinstance(input_value, Fraction): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

249 return input_value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

250 

251 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

252 return Fraction(input_value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

253 except ValueError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

254 raise PydanticCustomError('fraction_parsing', 'Input is not a valid fraction') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

255 

256 

257def forbid_inf_nan_check(x: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

258 if not math.isfinite(x): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

259 raise PydanticKnownError('finite_number') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

260 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

261 

262 

263def _safe_repr(v: Any) -> int | float | str: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

264 """The context argument for `PydanticKnownError` requires a number or str type, so we do a simple repr() coercion for types like timedelta. 

265 

266 See tests/test_types.py::test_annotated_metadata_any_order for some context. 

267 """ 

268 if isinstance(v, (int, float, str)): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

269 return v 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

270 return repr(v) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

271 

272 

273def greater_than_validator(x: Any, gt: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

274 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

275 if not (x > gt): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

276 raise PydanticKnownError('greater_than', {'gt': _safe_repr(gt)}) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

277 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

278 except TypeError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

279 raise TypeError(f"Unable to apply constraint 'gt' to supplied value {x}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

280 

281 

282def greater_than_or_equal_validator(x: Any, ge: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

283 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

284 if not (x >= ge): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

285 raise PydanticKnownError('greater_than_equal', {'ge': _safe_repr(ge)}) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

286 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

287 except TypeError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

288 raise TypeError(f"Unable to apply constraint 'ge' to supplied value {x}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

289 

290 

291def less_than_validator(x: Any, lt: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

292 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

293 if not (x < lt): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

294 raise PydanticKnownError('less_than', {'lt': _safe_repr(lt)}) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

295 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

296 except TypeError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

297 raise TypeError(f"Unable to apply constraint 'lt' to supplied value {x}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

298 

299 

300def less_than_or_equal_validator(x: Any, le: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

301 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

302 if not (x <= le): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

303 raise PydanticKnownError('less_than_equal', {'le': _safe_repr(le)}) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

304 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

305 except TypeError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

306 raise TypeError(f"Unable to apply constraint 'le' to supplied value {x}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

307 

308 

309def multiple_of_validator(x: Any, multiple_of: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

310 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

311 if x % multiple_of: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

312 raise PydanticKnownError('multiple_of', {'multiple_of': _safe_repr(multiple_of)}) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

313 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

314 except TypeError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

315 raise TypeError(f"Unable to apply constraint 'multiple_of' to supplied value {x}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

316 

317 

318def min_length_validator(x: Any, min_length: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

319 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

320 if not (len(x) >= min_length): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

321 raise PydanticKnownError( 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

322 'too_short', {'field_type': 'Value', 'min_length': min_length, 'actual_length': len(x)} 

323 ) 

324 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

325 except TypeError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

326 raise TypeError(f"Unable to apply constraint 'min_length' to supplied value {x}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

327 

328 

329def max_length_validator(x: Any, max_length: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

330 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

331 if len(x) > max_length: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

332 raise PydanticKnownError( 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

333 'too_long', 

334 {'field_type': 'Value', 'max_length': max_length, 'actual_length': len(x)}, 

335 ) 

336 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

337 except TypeError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

338 raise TypeError(f"Unable to apply constraint 'max_length' to supplied value {x}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

339 

340 

341def _extract_decimal_digits_info(decimal: Decimal) -> tuple[int, int]: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

342 """Compute the total number of digits and decimal places for a given [`Decimal`][decimal.Decimal] instance. 

343 

344 This function handles both normalized and non-normalized Decimal instances. 

345 Example: Decimal('1.230') -> 4 digits, 3 decimal places 

346 

347 Args: 

348 decimal (Decimal): The decimal number to analyze. 

349 

350 Returns: 

351 tuple[int, int]: A tuple containing the number of decimal places and total digits. 

352 

353 Though this could be divided into two separate functions, the logic is easier to follow if we couple the computation 

354 of the number of decimals and digits together. 

355 """ 

356 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

357 decimal_tuple = decimal.as_tuple() 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

358 

359 assert isinstance(decimal_tuple.exponent, int) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

360 

361 exponent = decimal_tuple.exponent 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

362 num_digits = len(decimal_tuple.digits) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

363 

364 if exponent >= 0: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

365 # A positive exponent adds that many trailing zeros 

366 # Ex: digit_tuple=(1, 2, 3), exponent=2 -> 12300 -> 0 decimal places, 5 digits 

367 num_digits += exponent 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

368 decimal_places = 0 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

369 else: 

370 # If the absolute value of the negative exponent is larger than the 

371 # number of digits, then it's the same as the number of digits, 

372 # because it'll consume all the digits in digit_tuple and then 

373 # add abs(exponent) - len(digit_tuple) leading zeros after the decimal point. 

374 # Ex: digit_tuple=(1, 2, 3), exponent=-2 -> 1.23 -> 2 decimal places, 3 digits 

375 # Ex: digit_tuple=(1, 2, 3), exponent=-4 -> 0.0123 -> 4 decimal places, 4 digits 

376 decimal_places = abs(exponent) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

377 num_digits = max(num_digits, decimal_places) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

378 

379 return decimal_places, num_digits 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

380 except (AssertionError, AttributeError): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

381 raise TypeError(f'Unable to extract decimal digits info from supplied value {decimal}') 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

382 

383 

384def max_digits_validator(x: Any, max_digits: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

385 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

386 _, num_digits = _extract_decimal_digits_info(x) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

387 _, normalized_num_digits = _extract_decimal_digits_info(x.normalize()) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

388 if (num_digits > max_digits) and (normalized_num_digits > max_digits): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

389 raise PydanticKnownError( 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

390 'decimal_max_digits', 

391 {'max_digits': max_digits}, 

392 ) 

393 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

394 except TypeError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

395 raise TypeError(f"Unable to apply constraint 'max_digits' to supplied value {x}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

396 

397 

398def decimal_places_validator(x: Any, decimal_places: Any) -> Any: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

399 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

400 decimal_places_, _ = _extract_decimal_digits_info(x) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

401 if decimal_places_ > decimal_places: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

402 normalized_decimal_places, _ = _extract_decimal_digits_info(x.normalize()) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

403 if normalized_decimal_places > decimal_places: 403 ↛ 408line 403 didn't jump to line 408 because the condition on line 403 was always true35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

404 raise PydanticKnownError( 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

405 'decimal_max_places', 

406 {'decimal_places': decimal_places}, 

407 ) 

408 return x 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

409 except TypeError: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

410 raise TypeError(f"Unable to apply constraint 'decimal_places' to supplied value {x}") 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

411 

412 

413def deque_validator(input_value: Any, handler: core_schema.ValidatorFunctionWrapHandler) -> collections.deque[Any]: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

414 return collections.deque(handler(input_value), maxlen=getattr(input_value, 'maxlen', None)) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

415 

416 

417def defaultdict_validator( 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

418 input_value: Any, handler: core_schema.ValidatorFunctionWrapHandler, default_default_factory: Callable[[], Any] 

419) -> collections.defaultdict[Any, Any]: 

420 if isinstance(input_value, collections.defaultdict): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

421 default_factory = input_value.default_factory 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

422 return collections.defaultdict(default_factory, handler(input_value)) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

423 else: 

424 return collections.defaultdict(default_default_factory, handler(input_value)) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

425 

426 

427def get_defaultdict_default_default_factory(values_source_type: Any) -> Callable[[], Any]: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

428 FieldInfo = import_cached_field_info() 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

429 

430 values_type_origin = get_origin(values_source_type) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

431 

432 def infer_default() -> Callable[[], Any]: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

433 allowed_default_types: dict[Any, Any] = { 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

434 tuple: tuple, 

435 collections.abc.Sequence: tuple, 

436 collections.abc.MutableSequence: list, 

437 list: list, 

438 typing.Sequence: list, 

439 set: set, 

440 typing.MutableSet: set, 

441 collections.abc.MutableSet: set, 

442 collections.abc.Set: frozenset, 

443 typing.MutableMapping: dict, 

444 typing.Mapping: dict, 

445 collections.abc.Mapping: dict, 

446 collections.abc.MutableMapping: dict, 

447 float: float, 

448 int: int, 

449 str: str, 

450 bool: bool, 

451 } 

452 values_type = values_type_origin or values_source_type 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

453 instructions = 'set using `DefaultDict[..., Annotated[..., Field(default_factory=...)]]`' 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

454 if typing_objects.is_typevar(values_type): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

455 

456 def type_var_default_factory() -> None: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

457 raise RuntimeError( 

458 'Generic defaultdict cannot be used without a concrete value type or an' 

459 ' explicit default factory, ' + instructions 

460 ) 

461 

462 return type_var_default_factory 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

463 elif values_type not in allowed_default_types: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

464 # a somewhat subjective set of types that have reasonable default values 

465 allowed_msg = ', '.join([t.__name__ for t in set(allowed_default_types.values())]) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

466 raise PydanticSchemaGenerationError( 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

467 f'Unable to infer a default factory for keys of type {values_source_type}.' 

468 f' Only {allowed_msg} are supported, other types require an explicit default factory' 

469 ' ' + instructions 

470 ) 

471 return allowed_default_types[values_type] 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

472 

473 # Assume Annotated[..., Field(...)] 

474 if typing_objects.is_annotated(values_type_origin): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

475 field_info = next((v for v in typing_extensions.get_args(values_source_type) if isinstance(v, FieldInfo)), None) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

476 else: 

477 field_info = None 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

478 if field_info and field_info.default_factory: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

479 # Assume the default factory does not take any argument: 

480 default_default_factory = cast(Callable[[], Any], field_info.default_factory) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

481 else: 

482 default_default_factory = infer_default() 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

483 return default_default_factory 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

484 

485 

486def validate_str_is_valid_iana_tz(value: Any, /) -> ZoneInfo: 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

487 if isinstance(value, ZoneInfo): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

488 return value 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

489 try: 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

490 return ZoneInfo(value) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

491 except (ZoneInfoNotFoundError, ValueError, TypeError): 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

492 raise PydanticCustomError('zoneinfo_str', 'invalid timezone: {value}', {'value': value}) 35 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHI

493 

494 

495NUMERIC_VALIDATOR_LOOKUP: dict[str, Callable] = { 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

496 'gt': greater_than_validator, 

497 'ge': greater_than_or_equal_validator, 

498 'lt': less_than_validator, 

499 'le': less_than_or_equal_validator, 

500 'multiple_of': multiple_of_validator, 

501 'min_length': min_length_validator, 

502 'max_length': max_length_validator, 

503 'max_digits': max_digits_validator, 

504 'decimal_places': decimal_places_validator, 

505} 

506 

507IpType = Union[IPv4Address, IPv6Address, IPv4Network, IPv6Network, IPv4Interface, IPv6Interface] 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

508 

509IP_VALIDATOR_LOOKUP: dict[type[IpType], Callable] = { 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

510 IPv4Address: ip_v4_address_validator, 

511 IPv6Address: ip_v6_address_validator, 

512 IPv4Network: ip_v4_network_validator, 

513 IPv6Network: ip_v6_network_validator, 

514 IPv4Interface: ip_v4_interface_validator, 

515 IPv6Interface: ip_v6_interface_validator, 

516} 

517 

518MAPPING_ORIGIN_MAP: dict[Any, Any] = { 42 ctx1abcdefghijklmnopqrstuvwxJKLMNOPyzABCDEFGHI

519 typing.DefaultDict: collections.defaultdict, # noqa: UP006 

520 collections.defaultdict: collections.defaultdict, 

521 typing.OrderedDict: collections.OrderedDict, # noqa: UP006 

522 collections.OrderedDict: collections.OrderedDict, 

523 typing_extensions.OrderedDict: collections.OrderedDict, 

524 typing.Counter: collections.Counter, 

525 collections.Counter: collections.Counter, 

526 # this doesn't handle subclasses of these 

527 typing.Mapping: dict, 

528 typing.MutableMapping: dict, 

529 # parametrized typing.{Mutable}Mapping creates one of these 

530 collections.abc.Mapping: dict, 

531 collections.abc.MutableMapping: dict, 

532}