Bunch of small fixes

Author: nielstron

range_ex/__init__.py

@@ -1,2 +1,3 @@
 __version__ = "1.1.0"
+from .range_regex import float_range_regex as float_range_regex
 from .range_regex import range_regex as range_regex

range_ex/range_regex.py

@@ -1,11 +1,13 @@
 from typing import Optional
 
+ANY_DIGIT = r"\d"
+
 
 def __digit_range(start: int, end: int) -> str:
     if start == end:
         return str(start)
     if start == 0 and end == 9:
-        return r"\d"
+        return ANY_DIGIT
     return f"[{start}-{end}]"
 
 
@@ -66,7 +68,7 @@ def __compute_numerical_range(str_a, str_b, start_appender_str=""):
     patterns = []
     if intermediate_range:
         patterns.append(
-            f"{start_appender_str}{__digit_range(intermediate_range[0], intermediate_range[-1])}{''.join([r'\d']*(str_len-1))}"
+            f"{start_appender_str}{__digit_range(intermediate_range[0], intermediate_range[-1])}{ANY_DIGIT * (str_len-1)}"
         )
     # patterns for the above part ['[2-4][0-9][0-9]']
 
@@ -81,7 +83,7 @@ def __compute_numerical_range(str_a, str_b, start_appender_str=""):
                 str_a[loop_counter + 1] != "9"
             ):  # if 599 then avoid 10 in '[6-8]...|5[10-9]..|59[9-9].|598[9-9]'
                 patterns.append(
-                    f"{start_appender_str}{str_a[:loop_counter+1]}{__digit_range(int(str_a[loop_counter+1]) + 1, 9)}{''.join([r'\d']*(str_len-2-loop_counter))}"
+                    f"{start_appender_str}{str_a[:loop_counter+1]}{__digit_range(int(str_a[loop_counter+1]) + 1, 9)}{ANY_DIGIT * (str_len-2-loop_counter)}"
                 )
     # patterns for the above part ['1[7-9][0-9]','16[9-9]']
 
@@ -96,7 +98,7 @@ def __compute_numerical_range(str_a, str_b, start_appender_str=""):
                 str_b[loop_counter + 1] != "0"
             ):  # if 1102 then avoid -1 in '11[0--1].|110[0-2]'
                 patterns.append(
-                    f"{start_appender_str}{str_b[:loop_counter+1]}{__digit_range(0, int(str_b[loop_counter+1]) - 1)}{''.join([r'\d']*(str_len-2-loop_counter))}"
+                    f"{start_appender_str}{str_b[:loop_counter+1]}{__digit_range(0, int(str_b[loop_counter+1]) - 1)}{ANY_DIGIT * (str_len-2-loop_counter)}"
                 )
     # patterns for the above part ['5[0-3][0-9]','54[0-3]']
 
@@ -158,7 +160,7 @@ def __range_splitter(a, b):
     return ranges
 
 
-def _range_regex(a, b):
+def _float_range_regex(a, b):
     """
     Generate regex for matching a number between a range.
     The regex might not be optimal but it serves the purpose.
@@ -167,78 +169,64 @@ def _range_regex(a, b):
     ie, If you pass two floating number the regex can only match floating number,
     else if you pass two integer number you can only mtach integer number.
     """
-    if a == 0 and b == 0:
-        return "-?0"
-    # Handling floating point numbers
-    if (isinstance(a, (float)) and isinstance(b, (float, int))) or (
-        isinstance(a, (float, int)) and isinstance(b, (float))
-    ):
-        a, b = (a, b) if a < b else (b, a)
-        num_of_decimal_in_a = len(str(float(a))) - (str(float(a)).find(".") + 1)
-        num_of_decimal_in_b = len(str(float(b))) - (str(float(b)).find(".") + 1)
-        max_num_decimal = max(num_of_decimal_in_a, num_of_decimal_in_b)
-
-        # Properly removing floating point and converting to integer
-        a, b = (
-            "".join([c for c in str(float(a)) if c != "."]),
-            "".join([c for c in str(float(b)) if c != "."]),
+    a, b = (a, b) if a < b else (b, a)
+    num_of_decimal_in_a = len(str(float(a))) - (str(float(a)).find(".") + 1)
+    num_of_decimal_in_b = len(str(float(b))) - (str(float(b)).find(".") + 1)
+    max_num_decimal = max(num_of_decimal_in_a, num_of_decimal_in_b)
+
+    # Properly removing floating point and converting to integer
+    a, b = (
+        "".join([c for c in str(float(a)) if c != "."]),
+        "".join([c for c in str(float(b)) if c != "."]),
+    )
+    if len(str(a)) < len(str(b)):
+        a = a + f"{'0'*(max_num_decimal-num_of_decimal_in_a)}"
+    else:
+        b = b + f"{'0'*(max_num_decimal-num_of_decimal_in_b)}"
+    a, b = int(a), int(b)
+    a, b = (a, b) if a < b else (b, a)
+
+    # Generate regex by treating float as integer
+    ranges = __range_splitter(a, b)
+    intermediate_regex = "|".join(
+        [
+            __compute_numerical_range(str(r[0]), str(r[1]), start_appender_str=r[2])
+            for r in ranges
+        ]
+    )
+
+    # Modifying the integer supported regex to support float
+    new_regex = []
+    for p in intermediate_regex.split("|"):
+        x = __tokenize_numeric_pattern(p[1:] if p.startswith("-") else p)
+
+        # If x = ['[0-9]'] and max_num_decimal = 2, We need x = ['0','[0-9]']
+        if len(x) < max_num_decimal:
+            x = (["0"] * (max_num_decimal - len(x))) + x
+
+        # Example x = ['3', '2', '[0-1]', '[0-9]'] for p=32[0-1][0-9]
+        start_appender_str = "-" if p.startswith("-") else ""
+        # Add a decimal point inbetween, keep the next digit mandatory and others optional (32.[0-1][0-9]?[0-9]*)
+        fractional_part = (
+            [x[-max_num_decimal]] + [z + "?" for z in x[-max_num_decimal + 1 :]]
+            if max_num_decimal > 1
+            else [z for z in x[-max_num_decimal:]]
         )
-        if len(str(a)) < len(str(b)):
-            a = a + f"{'0'*(max_num_decimal-num_of_decimal_in_a)}"
-        else:
-            b = b + f"{'0'*(max_num_decimal-num_of_decimal_in_b)}"
-        a, b = int(a), int(b)
-        a, b = (a, b) if a < b else (b, a)
-
-        # Generate regex by treating float as integer
-        ranges = __range_splitter(a, b)
-        intermediate_regex = "|".join(
-            [
-                __compute_numerical_range(str(r[0]), str(r[1]), start_appender_str=r[2])
-                for r in ranges
-            ]
+        non_fractional_part = (
+            "".join(x[:-max_num_decimal]) if "".join(x[:-max_num_decimal]) else "0?"
         )
+        new_regex.append(
+            rf"{start_appender_str}{non_fractional_part}\.{''.join(fractional_part)}\d*"
+        )
+    regex = f"(?:{'|'.join(new_regex)})"
+    return regex
 
-        # Modifying the integer supported regex to support float
-        new_regex = []
-        for p in intermediate_regex.split("|"):
-            x = __tokenize_numeric_pattern(p[1:] if p.startswith("-") else p)
-
-            # If x = ['[0-9]'] and max_num_decimal = 2, We need x = ['0','[0-9]']
-            if len(x) < max_num_decimal:
-                x = (["0"] * (max_num_decimal - len(x))) + x
-
-            # Example x = ['3', '2', '[0-1]', '[0-9]'] for p=32[0-1][0-9]
-            start_appender_str = "-" if p.startswith("-") else ""
-            # Add a decimal point inbetween, keep the next digit mandatory and others optional (32.[0-1][0-9]?[0-9]*)
-            fractional_part = (
-                [x[-max_num_decimal]] + [z + "?" for z in x[-max_num_decimal + 1 :]]
-                if max_num_decimal > 1
-                else [z for z in x[-max_num_decimal:]]
-            )
-            non_fractional_part = (
-                "".join(x[:-max_num_decimal]) if "".join(x[:-max_num_decimal]) else "0?"
-            )
-            new_regex.append(
-                rf"{start_appender_str}{non_fractional_part}\.{''.join(fractional_part)}\d*"
-            )
-        regex = f"(?:{'|'.join(new_regex)})"
-        return regex
 
-    # Handling integer numbers
-    elif isinstance(a, (int)) and isinstance(b, (int)):
-        a, b = (a, b) if a < b else (b, a)
-        ranges = __range_splitter(a, b)
-        regex = f"(?:{'|'.join([__compute_numerical_range(str(r[0]),str(r[1]),start_appender_str=r[2]) for r in ranges])})"
-        return regex
-
-    # Neither integer nor float
-    else:
-        raise (
-            ValueError(
-                f"Unsupported data types for {a}:{type(a)} or {b}:{type(a)}, Only supported float/int"
-            )
-        )
+def _range_regex(a: int, b: int):
+    a, b = (a, b) if a < b else (b, a)
+    ranges = __range_splitter(a, b)
+    regex = f"(?:{'|'.join([__compute_numerical_range(str(r[0]),str(r[1]),start_appender_str=r[2]) for r in ranges])})"
+    return regex
 
 
 def range_regex(minimum: Optional[int] = None, maximum: Optional[int] = None):
@@ -251,6 +239,11 @@ def range_regex(minimum: Optional[int] = None, maximum: Optional[int] = None):
     If you omit maximum, the regex will match all numbers larger than minimum (minimum must be < 0).
     If you omit both, all numbers will be matched.
     """
+    if minimum is not None and not isinstance(minimum, int):
+        raise TypeError(f"minimum must be int or None, got {type(minimum).__name__}")
+    if maximum is not None and not isinstance(maximum, int):
+        raise TypeError(f"maximum must be int or None, got {type(maximum).__name__}")
+
     if minimum is None and maximum is None:
         return r"-?(?:[1-9]\d*|0)"
     if minimum is None:
@@ -280,3 +273,14 @@ def range_regex(minimum: Optional[int] = None, maximum: Optional[int] = None):
             # now match any number with at least one more digit
             return rf"(?:{lowerbound_regex}|[1-9]\d{{{num_digits}}}\d*)"
     return _range_regex(minimum, maximum)
+
+
+def float_range_regex(minimum: float, maximum: float):
+    """
+    Generate regex for matching a floating-point number between a range, inclusive on both ends.
+    """
+    if not isinstance(minimum, (int, float)):
+        raise TypeError(f"minimum must be int or float, got {type(minimum).__name__}")
+    if not isinstance(maximum, (int, float)):
+        raise TypeError(f"maximum must be int or float, got {type(maximum).__name__}")
+    return _float_range_regex(minimum, maximum)

tests/test_range_regex.py

@@ -2,8 +2,9 @@
 
 from hypothesis import given, strategies as st, settings
 from hypothesis.strategies import one_of
+import pytest
 
-from range_ex import range_regex
+from range_ex import float_range_regex, range_regex
 
 NUM_EXAMPLES = 5000
 
@@ -36,6 +37,18 @@ def ranges_samples_above(draw):
     return (lower_bound, upper_bound, outside)
 
 
+@st.composite
+def float_ranges_and_values(draw):
+    lower_bound = draw(st.integers(min_value=-10000, max_value=10000))
+    upper_bound = draw(st.integers(min_value=lower_bound, max_value=10000))
+    value = draw(st.integers(min_value=-10000, max_value=10000))
+    return (lower_bound / 10, upper_bound / 10, value / 10)
+
+
+def _one_decimal_str(value: float) -> str:
+    return "0.0" if value == 0 else f"{value:.1f}"
+
+
 @given(ranges_samples_inside())
 @settings(max_examples=NUM_EXAMPLES)
 def test_numerical_range(pair):
@@ -89,3 +102,25 @@ def test_single_digit_class_uses_shorthand():
 def test_redundant_single_value_ranges_are_collapsed():
     generated_regex = range_regex(169, 543)
     assert re.search(r"\[([0-9])-\1\]", generated_regex) is None
+
+
+@given(float_ranges_and_values())
+@settings(max_examples=NUM_EXAMPLES)
+def test_float_range(pair):
+    (start_range, end_range, value) = pair
+    generated_regex = float_range_regex(start_range, end_range)
+    matched = re.compile(generated_regex).fullmatch(_one_decimal_str(value)) is not None
+    assert matched == (start_range <= value <= end_range)
+
+
+def test_range_regex_rejects_float_bounds():
+    with pytest.raises(TypeError):
+        range_regex(0.0, 10)
+    with pytest.raises(TypeError):
+        range_regex(0, 10.0)
+
+
+def test_range_regex_does_not_match_decimal_strings():
+    assert re.compile(range_regex()).fullmatch("0.0") is None
+    assert re.compile(range_regex(-10, 10)).fullmatch("0.0") is None
+    assert re.compile(range_regex(0, 0)).fullmatch("0.0") is None