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 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

7 

8import collections.abc 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

9import math 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

10import re 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

11import typing 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

12from decimal import Decimal 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

13from fractions import Fraction 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

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

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

16from zoneinfo import ZoneInfo, ZoneInfoNotFoundError 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

17 

18import typing_extensions 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

19from pydantic_core import PydanticCustomError, core_schema 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

20from pydantic_core._pydantic_core import PydanticKnownError 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

21from typing_inspection import typing_objects 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

22 

23from pydantic._internal._import_utils import import_cached_field_info 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

24from pydantic.errors import PydanticSchemaGenerationError 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

25 

26 

27def sequence_validator( 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

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

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)): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

38 raise PydanticCustomError( 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

50 input_value = list(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

51 

52 v_list = validator(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

53 

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

55 if value_type is list: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

56 return v_list 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

57 elif issubclass(value_type, range): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

59 return v_list 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

60 elif value_type is tuple: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

61 return tuple(v_list) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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] 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

65 

66 

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

68 if isinstance(value, str): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

69 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

70 return _import_string_logic(value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

71 except ImportError as e: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

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

73 else: 

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

75 return value 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

76 

77 

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

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

97 

98 components = dotted_path.strip().split(':') 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

99 if len(components) > 2: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

101 

102 module_path = components[0] 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

103 if not module_path: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

105 

106 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

107 module = import_module(module_path) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

108 except ModuleNotFoundError as e: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

109 if '.' in module_path: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

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) 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

112 try: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

113 return _import_string_logic(f'{maybe_module_path}:{maybe_attribute}') 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

114 except ImportError: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

115 pass 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

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

117 raise e 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

118 

119 if len(components) > 1: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

120 attribute = components[1] 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

121 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

122 return getattr(module, attribute) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

123 except AttributeError as e: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

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

125 else: 

126 return module 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

127 

128 

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

130 if isinstance(input_value, typing.Pattern): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

131 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

132 elif isinstance(input_value, (str, bytes)): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

133 # todo strict mode 

134 return compile_pattern(input_value) # type: ignore 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

135 else: 

136 raise PydanticCustomError('pattern_type', 'Input should be a valid pattern') 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

137 

138 

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

140 if isinstance(input_value, typing.Pattern): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

141 if isinstance(input_value.pattern, str): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

142 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

143 else: 

144 raise PydanticCustomError('pattern_str_type', 'Input should be a string pattern') 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

145 elif isinstance(input_value, str): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

146 return compile_pattern(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

147 elif isinstance(input_value, bytes): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

148 raise PydanticCustomError('pattern_str_type', 'Input should be a string pattern') 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

149 else: 

150 raise PydanticCustomError('pattern_type', 'Input should be a valid pattern') 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

151 

152 

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

154 if isinstance(input_value, typing.Pattern): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

155 if isinstance(input_value.pattern, bytes): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

156 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

157 else: 

158 raise PydanticCustomError('pattern_bytes_type', 'Input should be a bytes pattern') 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

159 elif isinstance(input_value, bytes): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

160 return compile_pattern(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

161 elif isinstance(input_value, str): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

162 raise PydanticCustomError('pattern_bytes_type', 'Input should be a bytes pattern') 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

163 else: 

164 raise PydanticCustomError('pattern_type', 'Input should be a valid pattern') 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

165 

166 

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

168 

169 

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

171 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

172 return re.compile(pattern) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

173 except re.error: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

174 raise PydanticCustomError('pattern_regex', 'Input should be a valid regular expression') 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

175 

176 

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

178 if isinstance(input_value, IPv4Address): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

179 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

180 

181 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

182 return IPv4Address(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

183 except ValueError: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

184 raise PydanticCustomError('ip_v4_address', 'Input is not a valid IPv4 address') 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

185 

186 

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

188 if isinstance(input_value, IPv6Address): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

189 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

190 

191 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

192 return IPv6Address(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

193 except ValueError: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

194 raise PydanticCustomError('ip_v6_address', 'Input is not a valid IPv6 address') 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

195 

196 

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

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): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

204 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

205 

206 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

207 return IPv4Network(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

208 except ValueError: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

209 raise PydanticCustomError('ip_v4_network', 'Input is not a valid IPv4 network') 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

210 

211 

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

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): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

219 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

220 

221 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

222 return IPv6Network(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

223 except ValueError: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

224 raise PydanticCustomError('ip_v6_network', 'Input is not a valid IPv6 network') 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

225 

226 

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

228 if isinstance(input_value, IPv4Interface): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

229 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

230 

231 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

232 return IPv4Interface(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

233 except ValueError: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

234 raise PydanticCustomError('ip_v4_interface', 'Input is not a valid IPv4 interface') 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

235 

236 

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

238 if isinstance(input_value, IPv6Interface): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

239 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

240 

241 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

242 return IPv6Interface(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

243 except ValueError: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

244 raise PydanticCustomError('ip_v6_interface', 'Input is not a valid IPv6 interface') 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

245 

246 

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

248 if isinstance(input_value, Fraction): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

249 return input_value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

250 

251 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

252 return Fraction(input_value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

253 except ValueError: 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

254 raise PydanticCustomError('fraction_parsing', 'Input is not a valid fraction') 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

255 

256 

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

258 if not math.isfinite(x): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

259 raise PydanticKnownError('finite_number') 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

260 return x 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

261 

262 

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

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)): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

269 return v 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

270 return repr(v) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

271 

272 

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

274 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

275 if not (x > gt): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

276 raise PydanticKnownError('greater_than', {'gt': _safe_repr(gt)}) 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

277 return x 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

278 except TypeError: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

280 

281 

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

283 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

284 if not (x >= ge): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

285 raise PydanticKnownError('greater_than_equal', {'ge': _safe_repr(ge)}) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

286 return x 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

287 except TypeError: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

289 

290 

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

292 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

293 if not (x < lt): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

294 raise PydanticKnownError('less_than', {'lt': _safe_repr(lt)}) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

295 return x 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

296 except TypeError: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

298 

299 

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

301 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

302 if not (x <= le): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

303 raise PydanticKnownError('less_than_equal', {'le': _safe_repr(le)}) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

304 return x 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

305 except TypeError: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

307 

308 

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

310 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

311 if x % multiple_of: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

312 raise PydanticKnownError('multiple_of', {'multiple_of': _safe_repr(multiple_of)}) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

313 return x 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

314 except TypeError: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

316 

317 

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

319 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

320 if not (len(x) >= min_length): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

321 raise PydanticKnownError( 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

323 ) 

324 return x 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

325 except TypeError: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

327 

328 

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

330 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

331 if len(x) > max_length: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

332 raise PydanticKnownError( 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

333 'too_long', 

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

335 ) 

336 return x 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

337 except TypeError: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

339 

340 

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

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

357 decimal_tuple = decimal.as_tuple() 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

358 

359 assert isinstance(decimal_tuple.exponent, int) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

360 

361 exponent = decimal_tuple.exponent 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

362 num_digits = len(decimal_tuple.digits) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

363 

364 if exponent >= 0: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

368 decimal_places = 0 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

377 num_digits = max(num_digits, decimal_places) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

378 

379 return decimal_places, num_digits 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

380 except (AssertionError, AttributeError): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

382 

383 

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

385 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

386 _, num_digits = _extract_decimal_digits_info(x) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

387 _, normalized_num_digits = _extract_decimal_digits_info(x.normalize()) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

388 if (num_digits > max_digits) and (normalized_num_digits > max_digits): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

389 raise PydanticKnownError( 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

390 'decimal_max_digits', 

391 {'max_digits': max_digits}, 

392 ) 

393 return x 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

394 except TypeError: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

396 

397 

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

399 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

400 decimal_places_, _ = _extract_decimal_digits_info(x) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

401 if decimal_places_ > decimal_places: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

402 normalized_decimal_places, _ = _extract_decimal_digits_info(x.normalize()) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

404 raise PydanticKnownError( 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

405 'decimal_max_places', 

406 {'decimal_places': decimal_places}, 

407 ) 

408 return x 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

409 except TypeError: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

411 

412 

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

414 return collections.deque(handler(input_value), maxlen=getattr(input_value, 'maxlen', None)) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

415 

416 

417def defaultdict_validator( 42 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

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): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

421 default_factory = input_value.default_factory 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

422 return collections.defaultdict(default_factory, handler(input_value)) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

423 else: 

424 return collections.defaultdict(default_default_factory, handler(input_value)) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

425 

426 

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

428 FieldInfo = import_cached_field_info() 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

429 

430 values_type_origin = get_origin(values_source_type) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

431 

432 def infer_default() -> Callable[[], Any]: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

433 allowed_default_types: dict[Any, Any] = { 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

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

454 if typing_objects.is_typevar(values_type): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

455 

456 def type_var_default_factory() -> None: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

463 elif values_type not in allowed_default_types: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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())]) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

466 raise PydanticSchemaGenerationError( 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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] 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

472 

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

474 if typing_objects.is_annotated(values_type_origin): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

476 else: 

477 field_info = None 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

478 if field_info and field_info.default_factory: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

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

480 default_default_factory = cast(Callable[[], Any], field_info.default_factory) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

481 else: 

482 default_default_factory = infer_default() 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

483 return default_default_factory 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

484 

485 

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

487 if isinstance(value, ZoneInfo): 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

488 return value 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

489 try: 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

490 return ZoneInfo(value) 41 ctx1abcdefghijklMmnopqrstuvwxyzOABCDEFGHIJKLN

491 except (ZoneInfoNotFoundError, ValueError, TypeError): 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

492 raise PydanticCustomError('zoneinfo_str', 'invalid timezone: {value}', {'value': value}) 38 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL

493 

494 

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

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 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

508 

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

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 ctx1abcdefghijklMmnopqrstuvwxyzOPABCDEFGHIJKLN

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}