Coverage for /home/runner/work/viur-core/viur-core/viur/src/viur/core/bones/numeric.py: 50%

129 statements  

« prev     ^ index     » next       coverage.py v7.9.2, created at 2025-07-03 12:27 +0000

1import logging 

2import numbers 

3import sys 

4import typing as t 

5import warnings 

6 

7from viur.core import db 

8from viur.core.bones.base import BaseBone, ReadFromClientError, ReadFromClientErrorSeverity 

9 

10if t.TYPE_CHECKING: 10 ↛ 11line 10 didn't jump to line 11 because the condition on line 10 was never true

11 from viur.core.skeleton import SkeletonInstance 

12 

13# Constants for Mne (MIN/MAX-never-exceed) 

14MIN = -(sys.maxsize - 1) 

15"""Constant for the minimum possible value in the system""" 

16MAX = sys.maxsize 

17"""Constant for the maximum possible value in the system 

18Also limited by the datastore (8 bytes). Halved for positive and negative values. 

19Which are around 2 ** (8 * 8 - 1) negative and 2 ** (8 * 8 - 1) positive values. 

20""" 

21 

22 

23class NumericBone(BaseBone): 

24 """ 

25 A bone for storing numeric values, either integers or floats. 

26 For floats, the precision can be specified in decimal-places. 

27 """ 

28 type = "numeric" 

29 

30 def __init__( 

31 self, 

32 *, 

33 min: int | float = MIN, 

34 max: int | float = MAX, 

35 precision: int = 0, 

36 mode=None, # deprecated! 

37 **kwargs 

38 ): 

39 """ 

40 Initializes a new NumericBone. 

41 

42 :param min: Minimum accepted value (including). 

43 :param max: Maximum accepted value (including). 

44 :param precision: How may decimal places should be saved. Zero casts the value to int instead of float. 

45 """ 

46 super().__init__(**kwargs) 

47 

48 if mode: 48 ↛ 49line 48 didn't jump to line 49 because the condition on line 48 was never true

49 logging.warning("mode-parameter to NumericBone is deprecated") 

50 warnings.warn( 

51 "mode-parameter to NumericBone is deprecated", DeprecationWarning 

52 ) 

53 

54 if not precision and mode == "float": 54 ↛ 55line 54 didn't jump to line 55 because the condition on line 54 was never true

55 logging.warning("mode='float' is deprecated, use precision=8 for same behavior") 

56 warnings.warn( 

57 "mode='float' is deprecated, use precision=8 for same behavior", DeprecationWarning 

58 ) 

59 precision = 8 

60 

61 self.precision = precision 

62 self.min = min 

63 self.max = max 

64 

65 def __setattr__(self, key, value): 

66 """ 

67 Sets the attribute with the specified key to the given value. 

68 

69 This method is overridden in the NumericBone class to handle the special case of setting 

70 the 'multiple' attribute to True while the bone is of type float. In this case, an 

71 AssertionError is raised to prevent creating a multiple float bone. 

72 

73 :param key: The name of the attribute to be set. 

74 :param value: The value to set the attribute to. 

75 :raises AssertionError: If the 'multiple' attribute is set to True for a float bone. 

76 """ 

77 if key in ("min", "max"): 

78 if value < MIN or value > MAX: 78 ↛ 79line 78 didn't jump to line 79 because the condition on line 78 was never true

79 raise ValueError(f"{key} can only be set to something between {MIN} and {MAX}") 

80 

81 return super().__setattr__(key, value) 

82 

83 def singleValueUnserialize(self, val): 

84 if val is not None: 

85 try: 

86 return self._convert_to_numeric(val) 

87 except (ValueError, TypeError): 

88 return self.getDefaultValue(None) # FIXME: callable needs the skeleton instance 

89 

90 return val 

91 

92 def singleValueSerialize(self, value, skel: 'SkeletonInstance', name: str, parentIndexed: bool): 

93 return self.singleValueUnserialize(value) # same logic for unserialize here! 

94 

95 def isInvalid(self, value): 

96 """ 

97 This method checks if a given value is invalid (e.g., NaN) for the NumericBone instance. 

98 

99 :param value: The value to be checked for validity. 

100 :return: Returns a string "NaN not allowed" if the value is invalid (NaN), otherwise None. 

101 """ 

102 if value != value: # NaN 102 ↛ 103line 102 didn't jump to line 103 because the condition on line 102 was never true

103 return "NaN not allowed" 

104 

105 def getEmptyValue(self): 

106 """ 

107 This method returns an empty value depending on the precision attribute of the NumericBone 

108 instance. 

109 

110 :return: Returns 0 for integers (when precision is 0) or 0.0 for floating-point numbers (when 

111 precision is non-zero). 

112 """ 

113 if self.precision: 

114 return 0.0 

115 else: 

116 return 0 

117 

118 def isEmpty(self, value: t.Any): 

119 """ 

120 This method checks if a given raw value is considered empty for the NumericBone instance. 

121 It attempts to convert the raw value into a valid numeric value (integer or floating-point 

122 number), depending on the precision attribute of the NumericBone instance. 

123 

124 :param value: The raw value to be checked for emptiness. 

125 :return: Returns True if the raw value is considered empty, otherwise False. 

126 """ 

127 if isinstance(value, str) and not value: 

128 return True 

129 try: 

130 value = self._convert_to_numeric(value) 

131 except (ValueError, TypeError): 

132 return True 

133 return value == self.getEmptyValue() 

134 

135 def singleValueFromClient(self, value, skel, bone_name, client_data): 

136 if not isinstance(value, (int, float)): 

137 # Replace , with . 

138 try: 

139 value = str(value).replace(",", ".", 1) 

140 except TypeError: 

141 return self.getEmptyValue(), [ReadFromClientError( 

142 ReadFromClientErrorSeverity.Invalid, "Cannot handle this value" 

143 )] 

144 # Convert to float or int -- depending on the precision 

145 # Since we convert direct to int if precision=0, a float value isn't valid 

146 try: 

147 value = float(value) if self.precision else int(value) 

148 except ValueError: 

149 return self.getEmptyValue(), [ReadFromClientError( 

150 ReadFromClientErrorSeverity.Invalid, 

151 f'Not a valid {"float" if self.precision else "int"} value' 

152 )] 

153 

154 assert isinstance(value, (int, float)) 

155 if self.precision: 

156 value = round(float(value), self.precision) 

157 else: 

158 value = int(value) 

159 

160 # Check the limits after rounding, as the rounding may change the value. 

161 if not (self.min <= value <= self.max): 

162 return self.getEmptyValue(), [ReadFromClientError( 

163 ReadFromClientErrorSeverity.Invalid, f"Value not between {self.min} and {self.max}" 

164 )] 

165 

166 if err := self.isInvalid(value): 166 ↛ 167line 166 didn't jump to line 167 because the condition on line 166 was never true

167 return self.getEmptyValue(), [ReadFromClientError(ReadFromClientErrorSeverity.Invalid, err)] 

168 

169 return value, None 

170 

171 def buildDBFilter( 

172 self, 

173 name: str, 

174 skel: "SkeletonInstance", 

175 dbFilter: db.Query, 

176 rawFilter: dict, 

177 prefix: t.Optional[str] = None 

178 ) -> db.Query: 

179 updatedFilter = {} 

180 

181 for parmKey, paramValue in rawFilter.items(): 

182 if parmKey.startswith(name): 

183 if parmKey != name and not parmKey.startswith(name + "$"): 

184 # It's just another bone which name start's with our's 

185 continue 

186 try: 

187 if not self.precision: 

188 paramValue = int(paramValue) 

189 else: 

190 paramValue = float(paramValue) 

191 except ValueError: 

192 # The value we should filter by is garbage, cancel this query 

193 logging.warning(f"Invalid filtering! Unparsable int/float supplied to NumericBone {name}") 

194 raise RuntimeError() 

195 updatedFilter[parmKey] = paramValue 

196 

197 return super().buildDBFilter(name, skel, dbFilter, updatedFilter, prefix) 

198 

199 def getSearchTags(self, skel: "SkeletonInstance", name: str) -> set[str]: 

200 """ 

201 This method generates a set of search tags based on the numeric values stored in the NumericBone 

202 instance. It iterates through the bone values and adds the string representation of each value 

203 to the result set. 

204 

205 :param skel: The skeleton instance containing the bone. 

206 :param name: The name of the bone. 

207 :return: Returns a set of search tags as strings. 

208 """ 

209 result = set() 

210 for idx, lang, value in self.iter_bone_value(skel, name): 

211 if value is None: 

212 continue 

213 result.add(str(value)) 

214 return result 

215 

216 def _convert_to_numeric(self, value: t.Any) -> int | float: 

217 """Convert a value to an int or float considering the precision. 

218 

219 If the value is not convertable an exception will be raised.""" 

220 if isinstance(value, db.Entity | dict) and "val" in value: 

221 value = value["val"] # was a StringBone before 

222 if isinstance(value, str): 

223 value = value.replace(",", ".", 1) 

224 if self.precision: 

225 return round(float(value), self.precision) 

226 else: 

227 # First convert to float then to int to support "42.5" (str) 

228 return int(float(value)) 

229 

230 def refresh(self, skel: "SkeletonInstance", boneName: str) -> None: 

231 """Ensure the value is numeric or None. 

232 

233 This ensures numeric values, for example after changing 

234 a bone from StringBone to a NumericBone. 

235 """ 

236 super().refresh(skel, boneName) 

237 

238 def refresh_single_value(value: t.Any) -> float | int: 

239 if value == "": 

240 return self.getEmptyValue() 

241 elif not isinstance(value, (int, float, type(None))): 

242 return self._convert_to_numeric(value) 

243 return value 

244 

245 # TODO: duplicate code, this is the same iteration logic as in StringBone 

246 new_value = {} 

247 for _, lang, value in self.iter_bone_value(skel, boneName): 

248 new_value.setdefault(lang, []).append(refresh_single_value(value)) 

249 

250 if not self.multiple: 

251 # take the first one 

252 new_value = {lang: values[0] for lang, values in new_value.items() if values} 

253 

254 if self.languages: 

255 skel[boneName] = new_value 

256 elif not self.languages: 

257 # just the value(s) with None language 

258 skel[boneName] = new_value.get(None, [] if self.multiple else self.getEmptyValue()) 

259 

260 def iter_bone_value( 

261 self, skel: "SkeletonInstance", name: str 

262 ) -> t.Iterator[tuple[t.Optional[int], t.Optional[str], t.Any]]: 

263 value = skel[name] 

264 if not value and isinstance(value, numbers.Number): 

265 # 0 and 0.0 are falsy, but can be valid numeric values and should be kept 

266 yield None, None, value 

267 yield from super().iter_bone_value(skel, name) 

268 

269 def structure(self) -> dict: 

270 return super().structure() | { 

271 "min": self.min, 

272 "max": self.max, 

273 "precision": self.precision, 

274 }