Bug fix for multiple wildcard words

changes/46.fix.rst

@@ -0,0 +1 @@
+Fix issue with multiple wildcard words using standalone engine

rita/__init__.py

@@ -9,7 +9,7 @@
 
 logger = logging.getLogger(__name__)
 
-__version__ = (0, 4, 0, os.getenv("VERSION_PATCH"))
+__version__ = (0, 4, 1, os.getenv("VERSION_PATCH"))
 
 
 def get_version():

rita/engine/translate_standalone.py

@@ -24,7 +24,8 @@ def any_of_parse(lst, op=None):
 
 
 def regex_parse(r, op=None):
-    return apply_operator(r, op)
+    initial = "(" + r + r"\s?" + ")"
+    return apply_operator(initial, op)
 
 
 def not_supported(key, *args, **kwargs):
@@ -50,11 +51,7 @@ def punct_parse(_, op=None):
 
 
 def word_parse(value, op=None):
-    if value:
-        initial = r"({})".format(value)
-    else:
-        initial = r"(\w+)"
-
+    initial = r"({}\s?)".format(value)
     return apply_operator(initial, op)
 
 
@@ -98,7 +95,7 @@ def gen():
         yield data[0]
 
         for (t, d, op) in data[1:]:
-            if t != "punct":
+            if t not in ["punct", "word", "prefix"]:
                 yield ("whitespace", None, None)
             yield (t, d, op)
 
@@ -119,15 +116,20 @@ def compile(self, label, rules):
         if self.config.ignore_case:
             flags = flags | re.IGNORECASE
 
-        return re.compile(r"(?P<{0}>{1})".format(label, "".join(rules)), flags)
+        regex_str = r"(?P<{0}>{1})".format(label, "".join(rules))
+        try:
+            return re.compile(regex_str, flags)
+        except Exception as ex:
+            logger.exception("Failed to compile: '{0}', Reason: \n{1}".format(regex_str, str(ex)))
+            return None
 
     def _results(self, text):
         for p in self.patterns:
             for match in p.finditer(text):
                 yield {
                     "start": match.start(),
                     "end": match.end(),
-                    "text": match.group(),
+                    "text": match.group().strip(),
                     "label": match.lastgroup,
                 }
 

tests/test_rules.py

@@ -239,13 +239,13 @@ def test_number(self):
         rules = self.compiler('NUM("42")->MARK("SOME_NUMBER")')
         print(rules)
         assert len(rules) == 1
-        assert rules[0] == re.compile(r"(?P<SOME_NUMBER>(42))", self.flags)
+        assert rules[0] == re.compile(r"(?P<SOME_NUMBER>(42\s?))", self.flags)
 
     def test_single_word(self):
         rules = self.compiler('WORD("Test")->MARK("SOME_LABEL")')
         print(rules)
         assert len(rules) == 1
-        assert rules[0] == re.compile(r"(?P<SOME_LABEL>(Test))", self.flags)
+        assert rules[0] == re.compile(r"(?P<SOME_LABEL>(Test\s?))", self.flags)
 
     def test_multiple_words(self):
         rules = self.compiler('''
@@ -262,27 +262,27 @@ def test_simple_pattern(self):
         ''')
         print(rules)
         assert len(rules) == 1
-        assert rules[0] == re.compile(r"(?P<SIMPLE_PATTERN>(test1)[.,!;?:]?\s(test2))", self.flags)
+        assert rules[0] == re.compile(r"(?P<SIMPLE_PATTERN>(test1\s?)[.,!;?:]?\s(test2\s?))", self.flags)
 
     def test_or_branch(self):
         rules = self.compiler('''
         {WORD("test1")|WORD("test2")}->MARK("SPLIT_LABEL")
         ''')
         print(rules)
         assert len(rules) == 2
-        assert rules[0] == re.compile(r"(?P<SPLIT_LABEL>(test1))", self.flags)
-        assert rules[1] == re.compile(r"(?P<SPLIT_LABEL>(test2))", self.flags)
+        assert rules[0] == re.compile(r"(?P<SPLIT_LABEL>(test1\s?))", self.flags)
+        assert rules[1] == re.compile(r"(?P<SPLIT_LABEL>(test2\s?))", self.flags)
 
     def test_or_branch_multi(self):
         rules = self.compiler('''
         {WORD("test1")|WORD("test2"),WORD("test3")|WORD("test4")}->MARK("MULTI_SPLIT_LABEL")
         ''')
         print(rules)
         assert len(rules) == 4
-        assert rules[0] == re.compile(r"(?P<MULTI_SPLIT_LABEL>(test1)[.,!;?:]?\s(test3))", self.flags)
-        assert rules[1] == re.compile(r"(?P<MULTI_SPLIT_LABEL>(test2)[.,!;?:]?\s(test3))", self.flags)
-        assert rules[2] == re.compile(r"(?P<MULTI_SPLIT_LABEL>(test1)[.,!;?:]?\s(test4))", self.flags)
-        assert rules[3] == re.compile(r"(?P<MULTI_SPLIT_LABEL>(test2)[.,!;?:]?\s(test4))", self.flags)
+        assert rules[0] == re.compile(r"(?P<MULTI_SPLIT_LABEL>(test1\s?)[.,!;?:]?\s(test3\s?))", self.flags)
+        assert rules[1] == re.compile(r"(?P<MULTI_SPLIT_LABEL>(test2\s?)[.,!;?:]?\s(test3\s?))", self.flags)
+        assert rules[2] == re.compile(r"(?P<MULTI_SPLIT_LABEL>(test1\s?)[.,!;?:]?\s(test4\s?))", self.flags)
+        assert rules[3] == re.compile(r"(?P<MULTI_SPLIT_LABEL>(test2\s?)[.,!;?:]?\s(test4\s?))", self.flags)
 
     def test_or_branch_multi_w_single(self):
         rules = self.compiler('''
@@ -292,19 +292,19 @@ def test_or_branch_multi_w_single(self):
         print(rules)
         assert len(rules) == 4
         assert rules[0] == re.compile(
-            r"(?P<MULTI_SPLIT_LABEL>(test1)[.,!;?:]?\s(one|three|two)[.,!;?:]?\s(test3))",
+            r"(?P<MULTI_SPLIT_LABEL>(test1\s?)[.,!;?:]?\s(one|three|two)[.,!;?:]?\s(test3\s?))",
             self.flags
         )
         assert rules[1] == re.compile(
-            r"(?P<MULTI_SPLIT_LABEL>(test2)[.,!;?:]?\s(one|three|two)[.,!;?:]?\s(test3))",
+            r"(?P<MULTI_SPLIT_LABEL>(test2\s?)[.,!;?:]?\s(one|three|two)[.,!;?:]?\s(test3\s?))",
             self.flags
         )
         assert rules[2] == re.compile(
-            r"(?P<MULTI_SPLIT_LABEL>(test1)[.,!;?:]?\s(one|three|two)[.,!;?:]?\s(test4))",
+            r"(?P<MULTI_SPLIT_LABEL>(test1\s?)[.,!;?:]?\s(one|three|two)[.,!;?:]?\s(test4\s?))",
             self.flags
         )
         assert rules[3] == re.compile(
-            r"(?P<MULTI_SPLIT_LABEL>(test2)[.,!;?:]?\s(one|three|two)[.,!;?:]?\s(test4))",
+            r"(?P<MULTI_SPLIT_LABEL>(test2\s?)[.,!;?:]?\s(one|three|two)[.,!;?:]?\s(test4\s?))",
             self.flags
         )
 
@@ -334,3 +334,11 @@ def test_list_with_accent(self):
         print(rules)
         assert len(rules) == 1
         assert rules[0] == re.compile(r"(?P<EXTENDED_LIST>(Jonas|Jurgis|Sarunas|Šarūnas))", self.flags)
+
+    def test_double_op(self):
+        rules = self.compiler('''
+        WORD+->MARK("DOUBLE_OP")
+        ''')
+        print(rules)
+        assert len(rules) == 1
+        assert rules[0] == re.compile(r"(?P<DOUBLE_OP>(\w+\s?)+)", self.flags)