Refactor the check

Author: Pierre-Sassoulas

pylint/checkers/format.py

@@ -548,7 +548,7 @@ def process_tokens(self, tokens: list[tokenize.TokenInfo]) -> None:
             self.add_message("trailing-newlines", line=line_num)
 
     @classmethod
-    def to_standard_or_engineering_base(cls, number):
+    def to_standard_or_engineering_base(cls, number: float) -> tuple[str, str]:
         """Calculate scientific notation components (base, exponent) for a number.
 
         Returns a tuple (base, exponent) where:
@@ -611,13 +611,11 @@ def to_standard_underscore_grouping(cls, number: float) -> str:
             # not use exponential notation for very small number even for strict
             # underscore grouping notation
             return number_str
-        print(number_str)
         if "." in number_str:
             int_part, dec_part = number_str.split(".")
         else:
             int_part = number_str
             dec_part = "0"
-        print("int_part", int_part, "dec_part:", dec_part)
         grouped_int_part = ""
         for i, digit in enumerate(reversed(int_part)):
             if i > 0 and i % 3 == 0:
@@ -628,62 +626,78 @@ def to_standard_underscore_grouping(cls, number: float) -> str:
     def _check_bad_float_notation(
         self, line_num: int, start: tuple[int, int], string: str
     ) -> None:
+
+        def raise_bad_float_notation(suggested: set[str]) -> None:
+            return self.add_message(
+                "bad-float-notation",
+                args=("' or '".join(suggested)),
+                line=line_num,
+                col_offset=start[1],
+                confidence=HIGH,
+            )
+
         value = float(string)
         threshold = self.linter.config.float_notation_threshold
         abs_value = abs(value)
         has_underscore = "_" in string
         has_exponent = "e" in string or "E" in string
-        violation = False
         if has_exponent:
             if self.linter.config.strict_underscore_notation:
                 # If we have exponent it means it's not proper underscore
-                violation = True
-                suggested = self.to_standard_underscore_grouping(value)
-            elif abs_value > threshold or abs_value < 1 / threshold:
+                return raise_bad_float_notation(
+                    {self.to_standard_underscore_grouping(value)}
+                )
+            if abs_value > threshold or abs_value < 1 / threshold:
                 value_as_str, exponent_as_str = string.lower().split("e")
                 value = float(value_as_str)
                 wrong_scientific_notation = (
                     self.should_check_scientific_notation and not (1 <= value < 10)
                 )
-                wrong_engineering_notation = (
-                    self.should_check_engineering_notation
-                    and not (1 <= value < 1000 and int(exponent_as_str) % 3 == 0)
-                )
                 if (
                     self.linter.config.strict_scientific_notation
                     and wrong_scientific_notation
                 ):
-                    suggested = self.to_standard_scientific_notation(value)
+                    return raise_bad_float_notation(
+                        {self.to_standard_scientific_notation(value)}
+                    )
+                wrong_engineering_notation = (
+                    self.should_check_engineering_notation
+                    and not (1 <= value < 1000 and int(exponent_as_str) % 3 == 0)
+                )
                 if (
                     self.linter.config.strict_engineering_notation
                     and wrong_engineering_notation
                 ):
-                    suggested = self.to_standard_engineering_notation(value)
+                    return raise_bad_float_notation(
+                        {self.to_standard_engineering_notation(value)}
+                    )
                 if wrong_scientific_notation and wrong_engineering_notation:
-                    suggested = f"{self.to_standard_scientific_notation(value)} or {self.to_standard_engineering_notation(value)}"
-        elif has_underscore:
+                    return raise_bad_float_notation(
+                        {
+                            self.to_standard_scientific_notation(value),
+                            self.to_standard_engineering_notation(value),
+                            self.to_standard_underscore_grouping(value),
+                        }
+                    )
+        if has_underscore:
+            # If we have underscore and exponent, we suggest exponent by default
             if self.linter.config.strict_scientific_notation:
-                violation = True
-                suggested = self.to_standard_scientific_notation(value)
-            elif self.linter.config.strict_engineering_notation:
-                violation = True
-                suggested = self.to_standard_engineering_notation(value)
-            else:
-                # If we have underscore and exponent, we suggest exponent by default
-                underscore_notation = has_underscore and re.match(
-                    r"^\d{0,3}(_\d{3})*\.?\d*([eE]-?\d{0,3}(_\d{3})*)?$", string
+                return raise_bad_float_notation(
+                    {self.to_standard_scientific_notation(value)}
                 )
-                suggested = self.to_standard_underscore_grouping(string)
-        # if "e" in number.lower() or "E" in number.lower():
-        #     return FormatChecker.to_standard_scientific_notation(float(number))
-        if violation:
-            self.add_message(
-                "bad-float-notation",
-                args=(suggested),
-                line=line_num,
-                col_offset=start[1],
-                confidence=HIGH,
+            if self.linter.config.strict_engineering_notation:
+                return raise_bad_float_notation(
+                    {self.to_standard_engineering_notation(value)}
+                )
+            underscore_notation = has_underscore and re.match(
+                r"^\d{0,3}(_\d{3})*\.?\d*([eE]-?\d{0,3}(_\d{3})*)?$", string
             )
+            if not underscore_notation:
+                return raise_bad_float_notation(
+                    {self.to_standard_underscore_grouping(value)}
+                )
+            return None
+        return None
 
     def _check_line_ending(self, line_ending: str, line_num: int) -> None:
         # check if line endings are mixed