feat: allow "n" as upper bound of repeatability (prevent parser crashes but don't do anything with the value yet) (#572)

* feat: allow `n` as upper bound of repeatability

#571

* wip

* isort

* python 3.9

* too many returns

and no added value

* mypy

* black

* Update src/ahbicht/models/mapping_results.py

Co-authored-by: Leon Haffmans <[email protected]>

* import

---------

Co-authored-by: Konstantin <[email protected]>
Co-authored-by: Leon Haffmans <[email protected]>

Author: 3 people

src/ahbicht/condition_node_distinction.py

@@ -6,7 +6,7 @@
 
 from ahbicht.models.condition_node_type import ConditionNodeType
 
-REGEX_PACKAGE_REPEATABILITY = re.compile(r"^(?P<n>\d)\.\.(?P<m>\d)$")
+REGEX_PACKAGE_REPEATABILITY = re.compile(r"^(?P<n>\d+)\.\.(?P<m>\d+|n)$")
 
 
 def derive_condition_node_type(condition_key: str) -> ConditionNodeType:
@@ -16,7 +16,7 @@ def derive_condition_node_type(condition_key: str) -> ConditionNodeType:
     if condition_key.endswith("P"):
         return ConditionNodeType.PACKAGE
     match = REGEX_PACKAGE_REPEATABILITY.match(condition_key)
-    if match and int(match.group("n")) <= int(match.group("m")):
+    if match:
         return ConditionNodeType.PACKAGE_REPEATABILITY
     if 1 <= int(condition_key) <= 499:
         return ConditionNodeType.REQUIREMENT_CONSTRAINT

src/ahbicht/expressions/ahb_expression_parser.py

@@ -26,7 +26,7 @@
 PREFIX_OPERATOR: "X"i | "O"i | "U"i
 MODAL_MARK: /M(uss)?|S(oll)?|K(ann)?/i
 // Matches if it looks like a condition expression, but does not yet check if it is a syntactically valid one:
-CONDITION_EXPRESSION: /(?!\BU\B)[\[\]\(\)U∧O∨X⊻\d\sP\.UB]+/i
+CONDITION_EXPRESSION: /(?!\BU\B)[\[\]\(\)U∧O∨X⊻\d\sP\.UBn]+/i
 """
 # Regarding the negative lookahead in the condition expression regex see examples https://regex101.com/r/6fFHD4/1
 # and CTRL+F for "Mus[2]" in the unittest that fails if you remove the lookahead.

src/ahbicht/expressions/condition_expression_parser.py

@@ -22,7 +22,7 @@
 GRAMMAR = r"""
 ?expression: expression "O"i expression -> or_composition
             | expression "∨" expression -> or_composition // the logical or
-            | expression "V"i expression -> or_composition // a 'v' for those who first chose to introduce logical symbols but now can't find them on their keyboard  
+            | expression "V"i expression -> or_composition // a 'v' for those who first chose to introduce logical symbols like ∨ but now can't find them on their keyboard  
             | expression "X"i expression -> xor_composition
             | expression "⊻" expression -> xor_composition
             | expression "U"i expression -> and_composition
@@ -38,7 +38,7 @@
 condition: "[" CONDITION_KEY "]" // a rule for condition keys
 TIME_CONDITION_KEY: /UB(1|2|3)/ // a terminal for "übergreifende Bedingungen für Zeitpunktangaben"
 CONDITION_KEY: INT // a TERMINAL for all the remaining ints (lower priority)
-REPEATABILITY: /\d+\.{2}[1-9]\d*/ // a terminal for repetitions n..m with n>=0 and m>n
+REPEATABILITY: /\d+\.{2}(?:([1-9]\d*)|n)/ // a terminal for repetitions n..m with n>=0 and m>n or m=="n"
 PACKAGE_KEY: INT "P" // a TERMINAL for all INTs followed by "P" (high priority)
 %import common.INT
 %import common.WS

src/ahbicht/models/mapping_results.py

@@ -2,7 +2,8 @@
 This module contains classes that are returned by mappers, meaning they contain a mapping.
 """
 
-from typing import Optional
+import math
+from typing import Literal, Optional, Union
 
 import attrs
 from efoli import EdifactFormat
@@ -96,9 +97,10 @@ def check_max_greater_or_equal_than_min(instance: "Repeatability", attribute, va
     """
     assert that 0<=min<max and not both min and max are 0
     """
-    if not 0 <= instance.min_occurrences <= instance.max_occurrences:
-        raise ValueError(f"0≤n≤m is not fulfilled for n={instance.min_occurrences}, m={instance.max_occurrences}")
-    if instance.min_occurrences == instance.max_occurrences == 0:
+    max_occurrences = math.inf if instance.max_occurrences == "n" else instance.max_occurrences
+    if not 0 <= instance.min_occurrences <= max_occurrences:
+        raise ValueError(f"0≤n≤m is not fulfilled for n={instance.min_occurrences}, m={max_occurrences}")
+    if instance.min_occurrences == max_occurrences == 0:
         raise ValueError("not both min and max occurrences must be 0")
 
 
@@ -116,8 +118,11 @@ class Repeatability:
     how often the segment/code has to be repeated (lower, inclusive bound); may be 0 for optional packages
     """
 
-    max_occurrences: int = attrs.field(
-        validator=attrs.validators.and_(attrs.validators.instance_of(int), check_max_greater_or_equal_than_min)
+    max_occurrences: Union[int, Literal["n"]] = attrs.field(
+        validator=attrs.validators.or_(  # type:ignore[misc]
+            attrs.validators.and_(attrs.validators.instance_of(int), check_max_greater_or_equal_than_min),
+            attrs.validators.in_("n"),
+        )
     )
     """
     how often the segment/coode may be repeated at most (upper, inclusive bound).

src/ahbicht/utility_functions.py

@@ -6,7 +6,7 @@
 import inspect
 import re
 from re import Match
-from typing import Awaitable, Callable, List, Optional, TypeVar, Union
+from typing import Awaitable, Callable, List, Literal, Optional, TypeVar, Union
 
 from lark import Tree
 
@@ -16,7 +16,9 @@
 Result = TypeVar("Result")
 
 
-_repeatability_pattern = re.compile(r"^(?P<min>\d+)\.{2}(?P<max>\d+)$")  #: a pattern to match "n..m" repeatabilities
+_repeatability_pattern = re.compile(
+    r"^(?P<min>\d+)\.{2}(?:(?P<max>\d+)|n)$"
+)  #: a pattern to match "n..m" repeatabilities
 
 
 async def gather_if_necessary(results_and_awaitable_results: List[Union[Result, Awaitable[Result]]]) -> List[Result]:
@@ -77,5 +79,9 @@ def parse_repeatability(repeatability_string: str) -> Repeatability:
     if match is None:
         raise ValueError(f"The given string '{repeatability_string}' could not be parsed as repeatability")
     min_repeatability = int(match["min"])
-    max_repeatability = int(match["max"])
+    max_repeatability: Union[int, Literal["n"]]
+    try:
+        max_repeatability = int(match["max"])
+    except TypeError:
+        max_repeatability = "n"
     return Repeatability(min_occurrences=min_repeatability, max_occurrences=max_repeatability)

unittests/test_utility_functions.py

@@ -44,6 +44,7 @@ async def test_gather_if_necessary(self, mixed_input: List[Union[T, Awaitable[T]
             pytest.param("1..1", Repeatability(min_occurrences=1, max_occurrences=1)),
             pytest.param("1..2", Repeatability(min_occurrences=1, max_occurrences=2)),
             pytest.param("71..89", Repeatability(min_occurrences=71, max_occurrences=89)),
+            pytest.param("71..n", Repeatability(min_occurrences=71, max_occurrences="n")),
         ],
     )
     def test_parse_repeatability(self, candidate: str, expected_result: Repeatability):

unittests/test_validity_check.py

@@ -70,6 +70,7 @@ def configure(binder):
             pytest.param(
                 "X ([950] [509] ∧ ([64] V [70])) V ([960] [522] ∧ [71] ∧ [53])", True
             ),  # nur echt mit 'V' statt LOR
+            pytest.param("X [1P0..n]", True),
         ],
     )
     async def test_is_valid_expression(self, ahb_expression: str, expected_result: bool, inject_cer_evaluators):