Coverage for heritrace/utils/datatypes_validation.py: 99%

1import base64 

2import re 

3from datetime import datetime 

4from urllib.parse import urlparse 

5 

6 

7def validate_string(value): 

8 try: 

9 value = str(value) 

10 return isinstance(value, str) 

11 except ValueError: 

12 return False 

13 

14 

15def validate_normalizedString(value): 

16 try: 

17 return "\n" not in value and "\r" not in value and "\t" not in value 

18 except Exception: 

19 return False 

20 

21 

22def validate_integer(value): 

23 try: 

24 int(value) 

25 return True 

26 except ValueError: 

27 return False 

28 

29 

30def validate_positive_integer(value): 

31 try: 

32 return int(value) > 0 

33 except ValueError: 

34 return False 

35 

36 

37def validate_negative_integer(value): 

38 try: 

39 return int(value) < 0 

40 except ValueError: 

41 return False 

42 

43 

44def validate_non_negative_integer(value): 

45 try: 

46 return int(value) >= 0 

47 except ValueError: 

48 return False 

49 

50 

51def validate_non_positive_integer(value): 

52 try: 

53 return int(value) <= 0 

54 except ValueError: 

55 return False 

56 

57 

58def validate_byte(value): 

59 try: 

60 val = int(value) 

61 return -128 <= val <= 127 

62 except ValueError: 

63 return False 

64 

65 

66def validate_short(value): 

67 try: 

68 val = int(value) 

69 return -32_768 <= val <= 32_767 

70 except ValueError: 

71 return False 

72 

73 

74def validate_long(value): 

75 try: 

76 val = int(value) 

77 return -2_147_483_648 <= val <= 2_147_483_647 

78 except ValueError: 

79 return False 

80 

81 

82def validate_unsigned_byte(value): 

83 try: 

84 val = int(value) 

85 return 0 <= val <= 255 

86 except ValueError: 

87 return False 

88 

89 

90def validate_unsigned_short(value): 

91 try: 

92 val = int(value) 

93 return 0 <= val <= 65_535 

94 except ValueError: 

95 return False 

96 

97 

98def validate_unsigned_long(value): 

99 try: 

100 val = int(value) 

101 return 0 <= val <= 4_294_967_295 

102 except ValueError: 

103 return False 

104 

105 

106def validate_unsigned_int(value): 

107 try: 

108 val = int(value) 

109 return 0 <= val <= 4_294_967_295 

110 except ValueError: 

111 return False 

112 

113 

114def validate_float(value): 

115 try: 

116 float(value) 

117 return True 

118 except ValueError: 

119 return False 

120 

121 

122def validate_double(value): 

123 try: 

124 float(value) 

125 return True 

126 except ValueError: 

127 return False 

128 

129 

130def validate_decimal(value): 

131 try: 

132 float(value) 

133 return True 

134 except ValueError: 

135 return False 

136 

137 

138def validate_duration(value): 

139 try: 

140 duration_pattern = re.compile( 

141 r"^P(?=\d|T\d)(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+?)?)S)?)?$" 

142 ) 

143 return bool(duration_pattern.match(value)) 

144 except Exception: 

145 return False 

146 

147 

148def validate_dayTimeDuration(value): 

149 try: 

150 dayTimeDuration_pattern = re.compile( 

151 r"^P(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$" 

152 ) 

153 return bool(dayTimeDuration_pattern.match(value)) 

154 except Exception: 

155 return False 

156 

157 

158def validate_yearMonthDuration(value): 

159 try: 

160 yearMonthDuration_pattern = re.compile(r"^P(?:\d+Y)?(?:\d+M)?$") 

161 return bool(yearMonthDuration_pattern.match(value)) 

162 except Exception: 

163 return False 

164 

165 

166def validate_gYearMonth(value): 

167 try: 

168 pattern = re.compile(r"^(\d{4})-(\d{2})$") 

169 match = pattern.match(value) 

170 if match: 

171 year, month = map(int, match.groups()) 

172 return year <= 9999 and 1 <= month <= 12 

173 return False 

174 except Exception: 

175 return False 

176 

177 

178def validate_gYear(value): 

179 try: 

180 pattern = re.compile(r"^\d{4}$") 

181 if pattern.match(value): 

182 year = int(value) 

183 return 1582 <= year <= 9999 

184 return False 

185 except Exception: 

186 return False 

187 

188 

189def validate_dateTime(value): 

190 try: 

191 pattern = re.compile( 

192 r"^-?\d{4,}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$" 

193 ) 

194 return bool(pattern.match(value)) 

195 except Exception: 

196 return False 

197 

198 

199def validate_dateTimeStamp(value): 

200 try: 

201 pattern = re.compile( 

202 r"^-?\d{4,}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(Z|[+-]\d{2}:\d{2})$" 

203 ) 

204 return bool(pattern.match(value)) 

205 except Exception: 

206 return False 

207 

208 

209def validate_date(value): 

210 try: 

211 datetime.strptime(value, "%Y-%m-%d").date() 

212 return True 

213 except ValueError: 

214 return False 

215 

216 

217def validate_time(value): 

218 try: 

219 return bool(re.match(r"^([01]\d|2[0-3]):?([0-5]\d):?([0-5]\d)$", value)) 

220 except Exception: 

221 return False 

222 

223 

224def validate_hour(value): 

225 try: 

226 return 0 <= int(value) <= 23 

227 except ValueError: 

228 return False 

229 

230 

231def validate_minute(value): 

232 try: 

233 return 0 <= int(value) <= 59 

234 except ValueError: 

235 return False 

236 

237 

238def validate_second(value): 

239 try: 

240 return 0 <= float(value) < 60 

241 except ValueError: 

242 return False 

243 

244 

245def validate_timezoneOffset(value): 

246 try: 

247 timezoneOffset_pattern = re.compile(r"^[+-]\d{2}:\d{2}$") 

248 return bool(timezoneOffset_pattern.match(value)) 

249 except Exception: 

250 return False 

251 

252 

253def validate_boolean(value): 

254 try: 

255 return value.lower() in ["true", "false"] 

256 except Exception: 

257 return False 

258 

259 

260def validate_hexBinary(value): 

261 try: 

262 bytes.fromhex(value) 

263 return True 

264 except ValueError: 

265 return False 

266 

267 

268def validate_base64Binary(value): 

269 try: 

270 base64.b64decode(value) 

271 return True 

272 except ValueError: 

273 return False 

274 

275 

276def validate_url(value): 

277 try: 

278 result = urlparse(value) 

279 return all([result.scheme, result.netloc]) 

280 except ValueError: 

281 return False 

282 

283 

284def validate_QName(value): 

285 try: 

286 QName_pattern = re.compile(r"^(?:[a-zA-Z_][\w.-]*:)?[a-zA-Z_][\w.-]*$") 

287 return bool(QName_pattern.match(value)) 

288 except Exception: 

289 return False 

290 

291 

292def validate_ENTITIES(value): 

293 try: 

294 entities = value.split() 

295 return all(re.match(r"^[a-zA-Z_][\w.-]*$", entity) for entity in entities) 

296 except Exception: 

297 return False 

298 

299 

300validate_ENTITY = validate_ENTITIES 

301 

302 

303def validate_ID(value): 

304 try: 

305 return re.match(r"^[a-zA-Z_][\w.-]*$", value) is not None 

306 except Exception: 

307 return False 

308 

309 

310validate_IDREF = validate_ID 

311validate_IDREFS = validate_ENTITIES 

312validate_NCName = validate_ID 

313 

314 

315def validate_NMTOKEN(value): 

316 try: 

317 return re.match(r"^[\w.-]+$", value) is not None 

318 except Exception: 

319 return False 

320 

321 

322def validate_NMTOKENS(value): 

323 try: 

324 tokens = value.split() 

325 return all(re.match(r"^[\w.-]+$", token) for token in tokens) 

326 except Exception: 

327 return False 

328 

329 

330validate_NOTATION = validate_QName 

331 

332 

333def validate_Name(value): 

334 try: 

335 return re.match(r"^[a-zA-Z_:][\w.-]*$", value) is not None 

336 except Exception: 

337 return False