Merge pull request #760 from Path-of-Modifiers/759-fix-text-roll-updating-regex

#759 Fix text roll updating regex

Author: Ivareh

src/backend_data_retrieval/data_retrieval_app/data_deposit/modifier/modifier_data/CaneOfKulemak.csv

@@ -10,7 +10,7 @@ minRoll,maxRoll,textRolls,position,effect,static,unique,veiled
 5,8,,0,"+#% to Quality of Socketed Support Gems",,True,True
 20,30,,0,"Enemies you Kill have a #% chance to Explode, dealing a quarter of their maximum Life as Chaos Damage",,True,True
 1,1,,0,"Socketed Gems are Supported by Level # #",,True,True
-,,"Cast While Channelling|Cast On Critical Strike",1,"Socketed Gems are Supported by Level # #",,True,True
+,,"Cast while Channelling|Cast On Critical Strike",1,"Socketed Gems are Supported by Level # #",,True,True
 12,14,,0,"#% chance to deal Double Damage",,True,True
 34,38,,0,"Minions have #% increased # Speed",,True,True
 ,,"Attack|Cast",1,"Minions have #% increased Ca#st Speed",,True,True

src/backend_data_retrieval/data_retrieval_app/data_deposit/modifier/modifier_data_depositor.py

@@ -10,6 +10,7 @@
     check_for_new_related_unique,
     check_for_updated_numerical_rolls,
     check_for_updated_text_rolls,
+    do_update_regex,
 )
 from data_retrieval_app.logs.logger import data_deposit_logger as logger
 from data_retrieval_app.utils import df_to_JSON
@@ -78,6 +79,7 @@ def _update_duplicates(
         update_url = self.data_url + "?modifierId={}"
 
         rolls = None
+        update_regex = False
         for (_, row_cur), (_, row_new) in zip(
             current_duplicate_modifiers_df.iterrows(),
             duplicate_df.iterrows(),
@@ -88,6 +90,7 @@ def _update_duplicates(
             position = int(data["position"])
             # if position is higher than 1, we want to store the types of rolls it has
             if position >= 1 and rolls is None:
+                update_regex = False
                 effect = data["effect"]
                 same_modifier_df = duplicate_df.loc[
                     duplicate_df["effect"] == effect
@@ -102,27 +105,30 @@ def _update_duplicates(
                     elif not pd.isna(same_modifier_row["textRolls"]):
                         rolls.append(same_modifier_row["textRolls"])
                     else:
-                        # We only need to check if the roll is of type float,
-                        # which we only need 'minRoll' for and not both 'minRoll' and 'maxRoll'
-                        rolls.append(same_modifier_row["minRoll"])
+                        rolls.append(None)
 
             if "updatedAt" in data:
                 data.pop("updatedAt")
 
             if not pd.isna(row_new["static"]):
                 pass
             elif not pd.isna(row_new["textRolls"]):
-                data, put_update = check_for_updated_text_rolls(
+                data, put_update, rolls = check_for_updated_text_rolls(
                     data=data,
                     row_new=row_new,
                     rolls=rolls,
                     regex_creator=self.regex_creator,
                 )
+                update_regex = put_update
             else:
                 data, put_update = check_for_updated_numerical_rolls(
                     data=data, row_new=row_new
                 )
 
+            if update_regex:
+                data = do_update_regex(data, rolls, regex_creator=self.regex_creator)
+                put_update = True
+
             data, put_update = check_for_additional_modifier_types(
                 data=data,
                 put_update=put_update,
@@ -160,6 +166,7 @@ def _update_duplicates(
             # We reset the rolls if the position is 0, because then the next row will be a new modifier
             if position == 0 and rolls is not None:
                 rolls = None
+                update_regex = False
 
     def _remove_duplicates(self, new_modifiers_df: pd.DataFrame) -> pd.DataFrame:
         current_modifiers_df = self._get_current_modifiers()
@@ -171,7 +178,11 @@ def _remove_duplicates(self, new_modifiers_df: pd.DataFrame) -> pd.DataFrame:
             return new_modifiers_df
 
         logger.info("Removing duplicate modifiers")
-        duplicate_mask = new_modifiers_df["effect"].isin(current_modifiers_df["effect"])
+        duplicate_mask = (
+            new_modifiers_df["effect"]
+            .str.lower()
+            .isin(current_modifiers_df["effect"].str.lower())
+        )
 
         duplicate_df = new_modifiers_df.loc[duplicate_mask].copy()
         self._update_duplicates(duplicate_df, current_modifiers_df)

src/backend_data_retrieval/data_retrieval_app/data_deposit/modifier/modifier_processing_modules.py

@@ -181,7 +181,7 @@ def _post_process(
 
         def remove_quantifier(ser: pd.Series) -> pd.Series:
             contains_q_mask = ser.str.contains("?", regex=False)
-            ser_contains_q = ser.loc[contains_q_mask]
+            ser_contains_q = ser.loc[contains_q_mask].copy()
 
             if ser_contains_q.empty:
                 return ser
@@ -231,27 +231,58 @@ def add_regex(self, modifier_df: pd.DataFrame) -> pd.DataFrame:
 def check_for_updated_text_rolls(
     data: dict[str, Any],
     row_new: pd.DataFrame,
-    rolls: list[int | str],
+    rolls: list[None | str],
     regex_creator: ModifierRegexCreator,
-) -> tuple[dict[str, Any], bool]:
+) -> tuple[dict[str, Any], bool, list[None | str]]:
     if data["textRolls"] != row_new["textRolls"]:
         logger.info(
             f"Found a modifier with new 'textRolls'. Modifier: {data['effect']}"
         )
-        data["textRolls"] = row_new["textRolls"]
+        new_rolls: list[str] = row_new["textRolls"].split("|")
+        old_rolls: list[str] = data["textRolls"].split("|")
+        combined_rolls = old_rolls + [
+            roll
+            for roll in new_rolls
+            if roll.lower() not in [old_roll.lower() for old_roll in old_rolls]
+        ]
         if rolls is not None:
-            data["rolls"] = rolls
-            data["effect"] = data["effect"].replace("+", r"\+")
-            data["regex"] = regex_creator.create_regex_from_row(data)
+            rolls[int(data["position"])] = "|".join(combined_rolls)
+            data["textRolls"] = rolls
+        else:
+            data["textRolls"] = [data["textRolls"]]
+
+        data["effect"] = data["effect"].replace("+", r"\+")
+        data["regex"] = regex_creator.create_regex_from_row(data)
+        data["effect"] = data["effect"].replace(r"\+", "+")
 
-            data["effect"] = data["effect"].replace(r"\+", "+")
-            data.pop("rolls")
+        data["textRolls"] = "|".join(combined_rolls)
 
         put_update = True
     else:
         put_update = False
 
-    return data, put_update
+    return data, put_update, rolls
+
+
+def do_update_regex(
+    data: dict[str, Any], rolls: list[None, str], regex_creator: ModifierRegexCreator
+) -> dict[str, Any]:
+    if "textRolls" in data:
+        text_rolls = data["textRolls"]
+    else:
+        text_rolls = None
+
+    data["textRolls"] = rolls
+    data["effect"] = data["effect"].replace("+", r"\+")
+    data["regex"] = regex_creator.create_regex_from_row(data)
+    data["effect"] = data["effect"].replace(r"\+", "+")
+
+    if text_rolls is not None:
+        data["textRolls"] = text_rolls
+    else:
+        data.pop("textRolls")
+
+    return data
 
 
 def check_for_updated_numerical_rolls(

src/backend_data_retrieval/data_retrieval_app/external_data_retrieval/transforming_data/roll_processor.py

@@ -95,7 +95,7 @@ def extract_rolls(matchobj: re.Match) -> str:
             index=False
         ):
             matched_modifiers = dynamic_df["modifier"].str.replace(
-                regex, extract_rolls, regex=True
+                regex, extract_rolls, regex=True, case=False
             )
             matched_modifiers_mask = matched_modifiers.str.contains("matched", na=False)
 
@@ -171,8 +171,8 @@ def _process_dynamic(
         def convert_text_roll_to_index(row: pd.DataFrame) -> int:
             text_rolls: str = row["textRolls"]
             if text_rolls != "None":
-                text_rolls = text_rolls.split("|")
-                roll = text_rolls.index(row["roll"])
+                text_rolls = text_rolls.lower().split("|")
+                roll = text_rolls.index(row["roll"].lower())
             else:
                 roll = row["roll"]