endoreg-db 0.8.9.2__py3-none-any.whl → 0.8.9.10__py3-none-any.whl

endoreg_db/utils/requirement_operator_logic/_old/lab_value_operators.py

@@ -1,24 +1,30 @@
 from typing import TYPE_CHECKING, List, Optional, Callable, Dict, Any
-import re # Added import
+import re  # Added import
 from endoreg_db.models.medical.patient.patient_lab_value import PatientLabValue
 from endoreg_db.models.requirement.requirement import Requirement
 from datetime import datetime, timedelta
 
 if TYPE_CHECKING:
-    from endoreg_db.utils.links.requirement_link import RequirementLinks # Added import
+    from endoreg_db.utils.links.requirement_link import RequirementLinks  # Added import
     # from endoreg_db.models.requirement.requirement_operator import RequirementOperator # No longer directly used here
 
-def get_latest_patient_lab_value(patient_lab_values: List[PatientLabValue], lab_value_name: str) -> Optional[PatientLabValue]:
+
+def get_latest_patient_lab_value(
+    patient_lab_values: List[PatientLabValue], lab_value_name: str
+) -> Optional[PatientLabValue]:
     """
     Retrieves the most recent PatientLabValue for a specific lab_value_name.
     """
     relevant_values = [
-        plv for plv in patient_lab_values if plv.lab_value and plv.lab_value.name == lab_value_name
+        plv
+        for plv in patient_lab_values
+        if plv.lab_value and plv.lab_value.name == lab_value_name
     ]
     if not relevant_values:
         return None
     return max(relevant_values, key=lambda plv: plv.datetime)
 
+
 def get_patient_lab_values_in_timeframe(
     patient_lab_values: List[PatientLabValue],
     lab_value_name: str,
@@ -32,7 +38,9 @@ def get_patient_lab_values_in_timeframe(
     days_max: e.g., 0 for today (end of timeframe)
     """
     relevant_values = [
-        plv for plv in patient_lab_values if plv.lab_value and plv.lab_value.name == lab_value_name
+        plv
+        for plv in patient_lab_values
+        if plv.lab_value and plv.lab_value.name == lab_value_name
     ]
     if not relevant_values:
         return []
@@ -57,78 +65,90 @@ def get_patient_lab_values_in_timeframe(
 
 
 def lab_latest_numeric_increased(
-    input_links: "RequirementLinks", # Changed
+    input_links: "RequirementLinks",  # Changed
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Returns True if the latest numeric lab value for all required lab values is above the normal maximum range; otherwise returns False.
-    
+
     Returns False if any required lab value is missing, the latest value is unavailable, or the value does not exceed the normal maximum.
     """
     patient_lab_values = input_links.patient_lab_values
     if not requirement.lab_values.exists():
         return False
     for lab_value_model in requirement.lab_values.all():
-        latest_plv = get_latest_patient_lab_value(patient_lab_values, lab_value_model.name)
+        latest_plv = get_latest_patient_lab_value(
+            patient_lab_values, lab_value_model.name
+        )
         if not (latest_plv and latest_plv.value is not None and latest_plv.lab_value):
             return False
         patient_context = input_links.get_first_patient()
         normal_range = latest_plv.lab_value.get_normal_range(
             age=patient_context.age() if patient_context else None,
-            gender=patient_context.gender if patient_context else None
+            gender=patient_context.gender if patient_context else None,
         )
         if normal_range.get("max") is None or latest_plv.value <= normal_range["max"]:
             return False
     return True
 
+
 def lab_latest_numeric_decreased(
-    input_links: "RequirementLinks", # Changed
+    input_links: "RequirementLinks",  # Changed
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Returns True if the latest numeric lab value for all required lab values is below the normal minimum range.
-    
+
     Returns False if any latest value is missing, lacks a normal range, or is not below the minimum.
     """
     patient_lab_values = input_links.patient_lab_values
-    if not requirement.lab_values.exists(): # Changed
+    if not requirement.lab_values.exists():  # Changed
         return False
     for lab_value_model in requirement.lab_values.all():
-        latest_plv = get_latest_patient_lab_value(patient_lab_values, lab_value_model.name)
-        if not (latest_plv and latest_plv.value is not None and latest_plv.lab_value): # Added check for latest_plv.lab_value
+        latest_plv = get_latest_patient_lab_value(
+            patient_lab_values, lab_value_model.name
+        )
+        if not (
+            latest_plv and latest_plv.value is not None and latest_plv.lab_value
+        ):  # Added check for latest_plv.lab_value
             return False
         patient_context = input_links.get_first_patient()
         normal_range = latest_plv.lab_value.get_normal_range(
-            age=patient_context.age() if patient_context else None, 
-            gender=patient_context.gender if patient_context else None
+            age=patient_context.age() if patient_context else None,
+            gender=patient_context.gender if patient_context else None,
         )
         if normal_range.get("min") is None or latest_plv.value >= normal_range["min"]:
             return False
     return True
 
+
 def lab_latest_numeric_normal(
-    input_links: "RequirementLinks", # Changed
+    input_links: "RequirementLinks",  # Changed
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Returns True if the latest numeric lab value for all required lab values is within the normal range.
-    
+
     Returns False if any latest value is missing, lacks a normal range, or falls outside the normal range.
     """
     patient_lab_values = input_links.patient_lab_values
-    if not requirement.lab_values.exists(): # Changed
+    if not requirement.lab_values.exists():  # Changed
         return False
     for lab_value_model in requirement.lab_values.all():
-        latest_plv = get_latest_patient_lab_value(patient_lab_values, lab_value_model.name)
-        if not (latest_plv and latest_plv.value is not None and latest_plv.lab_value): # Added check for latest_plv.lab_value
+        latest_plv = get_latest_patient_lab_value(
+            patient_lab_values, lab_value_model.name
+        )
+        if not (
+            latest_plv and latest_plv.value is not None and latest_plv.lab_value
+        ):  # Added check for latest_plv.lab_value
             return False
         patient_context = input_links.get_first_patient()
         normal_range = latest_plv.lab_value.get_normal_range(
-            age=patient_context.age() if patient_context else None, 
-            gender=patient_context.gender if patient_context else None
+            age=patient_context.age() if patient_context else None,
+            gender=patient_context.gender if patient_context else None,
         )
         min_val = normal_range.get("min")
         max_val = normal_range.get("max")
@@ -138,54 +158,66 @@ def lab_latest_numeric_normal(
             return False
     return True
 
+
 def lab_latest_numeric_lower_than_value(
-    input_links: "RequirementLinks", # Changed
+    input_links: "RequirementLinks",  # Changed
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Returns True if the latest numeric lab value for all required lab values is lower than the specified threshold.
-    
+
     Returns False if any latest value is missing or not below the requirement's numeric value.
     """
     patient_lab_values = input_links.patient_lab_values
-    if not requirement.lab_values.exists() or requirement.numeric_value is None: # Changed
+    if (
+        not requirement.lab_values.exists() or requirement.numeric_value is None
+    ):  # Changed
         return False
     for lab_value_model in requirement.lab_values.all():
-        latest_plv = get_latest_patient_lab_value(patient_lab_values, lab_value_model.name)
+        latest_plv = get_latest_patient_lab_value(
+            patient_lab_values, lab_value_model.name
+        )
         if not (latest_plv and latest_plv.value is not None):
             return False
         if not (latest_plv.value < requirement.numeric_value):
             return False
     return True
 
+
 def lab_latest_numeric_greater_than_value(
-    input_links: "RequirementLinks", # Changed
+    input_links: "RequirementLinks",  # Changed
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Returns True if the latest numeric lab value for all required lab values is greater than the specified threshold.
-    
+
     Returns False if any latest value is missing or not greater than the requirement's numeric value.
     """
     patient_lab_values = input_links.patient_lab_values
-    if not requirement.lab_values.exists() or requirement.numeric_value is None: # Changed
+    if (
+        not requirement.lab_values.exists() or requirement.numeric_value is None
+    ):  # Changed
         return False
     for lab_value_model in requirement.lab_values.all():
-        latest_plv = get_latest_patient_lab_value(patient_lab_values, lab_value_model.name)
+        latest_plv = get_latest_patient_lab_value(
+            patient_lab_values, lab_value_model.name
+        )
         if not (latest_plv and latest_plv.value is not None):
             return False
         if not (latest_plv.value > requirement.numeric_value):
             return False
     return True
 
+
 # --- Operators with timeframe ---
 
+
 def lab_latest_numeric_increased_factor_in_timeframe(
-    input_links: "RequirementLinks", # Changed
+    input_links: "RequirementLinks",  # Changed
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if the numeric lab value has increased by a certain factor within a timeframe.
@@ -197,21 +229,29 @@ def lab_latest_numeric_increased_factor_in_timeframe(
     More sophisticated checks (e.g., sustained increase, comparison to earliest value in overall history) might require different logic.
     """
     patient_lab_values = input_links.patient_lab_values
-    if (not requirement.lab_values.exists() or
-        requirement.numeric_value is None or
-        requirement.numeric_value_min is None or
-        requirement.numeric_value_max is None):
+    if (
+        not requirement.lab_values.exists()
+        or requirement.numeric_value is None
+        or requirement.numeric_value_min is None
+        or requirement.numeric_value_max is None
+    ):
         return False
 
     factor = requirement.numeric_value
-    days_min = int(requirement.numeric_value_min) # Start of timeframe
-    days_max = int(requirement.numeric_value_max) # End of timeframe
+    days_min = int(requirement.numeric_value_min)  # Start of timeframe
+    days_max = int(requirement.numeric_value_max)  # End of timeframe
 
     for lab_value_model in requirement.lab_values.all():
         # Get all values for this lab type, not just within the timeframe initially
         all_lab_values_for_type = sorted(
-            [plv for plv in patient_lab_values if plv.lab_value and plv.lab_value.name == lab_value_model.name and plv.value is not None],
-            key=lambda plv: plv.datetime
+            [
+                plv
+                for plv in patient_lab_values
+                if plv.lab_value
+                and plv.lab_value.name == lab_value_model.name
+                and plv.value is not None
+            ],
+            key=lambda plv: plv.datetime,
         )
 
         if not all_lab_values_for_type:
@@ -224,10 +264,11 @@ def lab_latest_numeric_increased_factor_in_timeframe(
             if plv.datetime.date() <= start_of_timeframe_date:
                 reference_plv = plv
                 break
-        
-        if reference_plv is None and all_lab_values_for_type: # if no value before timeframe, use earliest available
-             reference_plv = all_lab_values_for_type[0]
 
+        if (
+            reference_plv is None and all_lab_values_for_type
+        ):  # if no value before timeframe, use earliest available
+            reference_plv = all_lab_values_for_type[0]
 
         if reference_plv and reference_plv.value is not None:
             reference_value = reference_plv.value
@@ -236,14 +277,17 @@ def lab_latest_numeric_increased_factor_in_timeframe(
                 patient_lab_values, lab_value_model.name, days_min, days_max
             )
             for plv_in_frame in values_in_timeframe:
-                if plv_in_frame.value is not None and plv_in_frame.value > (reference_value * factor):
-                    return True # Found a value increased by the factor
+                if plv_in_frame.value is not None and plv_in_frame.value > (
+                    reference_value * factor
+                ):
+                    return True  # Found a value increased by the factor
     return False
 
+
 def lab_latest_numeric_decreased_factor_in_timeframe(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if the numeric lab value has decreased by a certain factor within a timeframe.
@@ -251,10 +295,12 @@ def lab_latest_numeric_decreased_factor_in_timeframe(
     Compares values in timeframe to the value at the start of (or just before) the timeframe.
     """
     patient_lab_values = input_links.patient_lab_values
-    if (not requirement.lab_values.exists() or
-        requirement.numeric_value is None or
-        requirement.numeric_value_min is None or
-        requirement.numeric_value_max is None):
+    if (
+        not requirement.lab_values.exists()
+        or requirement.numeric_value is None
+        or requirement.numeric_value_min is None
+        or requirement.numeric_value_max is None
+    ):
         return False
 
     factor = requirement.numeric_value
@@ -263,8 +309,14 @@ def lab_latest_numeric_decreased_factor_in_timeframe(
 
     for lab_value_model in requirement.lab_values.all():
         all_lab_values_for_type = sorted(
-            [plv for plv in patient_lab_values if plv.lab_value and plv.lab_value.name == lab_value_model.name and plv.value is not None],
-            key=lambda plv: plv.datetime
+            [
+                plv
+                for plv in patient_lab_values
+                if plv.lab_value
+                and plv.lab_value.name == lab_value_model.name
+                and plv.value is not None
+            ],
+            key=lambda plv: plv.datetime,
         )
         if not all_lab_values_for_type:
             continue
@@ -280,29 +332,36 @@ def lab_latest_numeric_decreased_factor_in_timeframe(
 
         if reference_plv and reference_plv.value is not None:
             reference_value = reference_plv.value
-            if reference_value == 0: # Avoid division by zero or issues with zero reference
-                continue 
+            if (
+                reference_value == 0
+            ):  # Avoid division by zero or issues with zero reference
+                continue
             values_in_timeframe = get_patient_lab_values_in_timeframe(
                 patient_lab_values, lab_value_model.name, days_min, days_max
             )
             for plv_in_frame in values_in_timeframe:
-                if plv_in_frame.value is not None and plv_in_frame.value < (reference_value / factor): # Decreased by factor
+                if plv_in_frame.value is not None and plv_in_frame.value < (
+                    reference_value / factor
+                ):  # Decreased by factor
                     return True
     return False
 
+
 def lab_latest_numeric_normal_in_timeframe(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if any numeric lab value within a timeframe is within its normal range.
     Timeframe in requirement.numeric_value_min/max.
     """
     patient_lab_values = input_links.patient_lab_values
-    if (not requirement.lab_values.exists() or
-        requirement.numeric_value_min is None or
-        requirement.numeric_value_max is None):
+    if (
+        not requirement.lab_values.exists()
+        or requirement.numeric_value_min is None
+        or requirement.numeric_value_max is None
+    ):
         return False
 
     days_min = int(requirement.numeric_value_min)
@@ -317,7 +376,7 @@ def lab_latest_numeric_normal_in_timeframe(
             if plv.value is not None and plv.lab_value:
                 normal_range = plv.lab_value.get_normal_range(
                     age=patient_context.age() if patient_context else None,
-                    gender=patient_context.gender if patient_context else None
+                    gender=patient_context.gender if patient_context else None,
                 )
                 min_val = normal_range.get("min")
                 max_val = normal_range.get("max")
@@ -326,20 +385,23 @@ def lab_latest_numeric_normal_in_timeframe(
                         return True
     return False
 
+
 def lab_latest_numeric_lower_than_value_in_timeframe(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if any numeric lab value within a timeframe is lower than requirement.numeric_value.
     Timeframe in requirement.numeric_value_min/max.
     """
     patient_lab_values = input_links.patient_lab_values
-    if (not requirement.lab_values.exists() or
-        requirement.numeric_value is None or
-        requirement.numeric_value_min is None or
-        requirement.numeric_value_max is None):
+    if (
+        not requirement.lab_values.exists()
+        or requirement.numeric_value is None
+        or requirement.numeric_value_min is None
+        or requirement.numeric_value_max is None
+    ):
         return False
 
     threshold = requirement.numeric_value
@@ -355,20 +417,23 @@ def lab_latest_numeric_lower_than_value_in_timeframe(
                 return True
     return False
 
+
 def lab_latest_numeric_greater_than_value_in_timeframe(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if any numeric lab value within a timeframe is greater than requirement.numeric_value.
     Timeframe in requirement.numeric_value_min/max.
     """
     patient_lab_values = input_links.patient_lab_values
-    if (not requirement.lab_values.exists() or
-        requirement.numeric_value is None or
-        requirement.numeric_value_min is None or
-        requirement.numeric_value_max is None):
+    if (
+        not requirement.lab_values.exists()
+        or requirement.numeric_value is None
+        or requirement.numeric_value_min is None
+        or requirement.numeric_value_max is None
+    ):
         return False
 
     threshold = requirement.numeric_value
@@ -384,13 +449,15 @@ def lab_latest_numeric_greater_than_value_in_timeframe(
                 return True
     return False
 
+
 # --- Categorical Operators ---
 # Assuming PatientLabValue has a 'value_string' attribute for categorical results.
 
+
 def lab_latest_categorical_match(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if the latest categorical lab value matches requirement.string_value.
@@ -401,17 +468,24 @@ def lab_latest_categorical_match(
 
     match_string = requirement.string_value
     for lab_value_model in requirement.lab_values.all():
-        latest_plv = get_latest_patient_lab_value(patient_lab_values, lab_value_model.name)
+        latest_plv = get_latest_patient_lab_value(
+            patient_lab_values, lab_value_model.name
+        )
         # Ensure latest_plv has value_str attribute
-        if latest_plv and hasattr(latest_plv, 'value_str') and latest_plv.value_str is not None: # Changed value_string to value_str
+        if (
+            latest_plv
+            and hasattr(latest_plv, "value_str")
+            and latest_plv.value_str is not None
+        ):  # Changed value_string to value_str
             if latest_plv.value_str == match_string:
                 return True
     return False
 
+
 def lab_latest_categorical_match_substring(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if requirement.string_value is a substring of the latest categorical lab value.
@@ -422,16 +496,23 @@ def lab_latest_categorical_match_substring(
 
     substring = requirement.string_value
     for lab_value_model in requirement.lab_values.all():
-        latest_plv = get_latest_patient_lab_value(patient_lab_values, lab_value_model.name)
-        if latest_plv and hasattr(latest_plv, 'value_str') and latest_plv.value_str is not None: # Changed value_string to value_str
+        latest_plv = get_latest_patient_lab_value(
+            patient_lab_values, lab_value_model.name
+        )
+        if (
+            latest_plv
+            and hasattr(latest_plv, "value_str")
+            and latest_plv.value_str is not None
+        ):  # Changed value_string to value_str
             if substring in latest_plv.value_str:
                 return True
     return False
 
+
 def lab_latest_categorical_match_regex(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if the latest categorical lab value matches regex in requirement.string_value.
@@ -444,31 +525,41 @@ def lab_latest_categorical_match_regex(
     try:
         compiled_regex = re.compile(regex_pattern)
     except re.error:
-        return False # Invalid regex
+        return False  # Invalid regex
 
     for lab_value_model in requirement.lab_values.all():
-        latest_plv = get_latest_patient_lab_value(patient_lab_values, lab_value_model.name)
-        if latest_plv and hasattr(latest_plv, 'value_str') and latest_plv.value_str is not None: # Changed value_string to value_str
+        latest_plv = get_latest_patient_lab_value(
+            patient_lab_values, lab_value_model.name
+        )
+        if (
+            latest_plv
+            and hasattr(latest_plv, "value_str")
+            and latest_plv.value_str is not None
+        ):  # Changed value_string to value_str
             if compiled_regex.search(latest_plv.value_str):
                 return True
     return False
 
+
 # --- Categorical Operators with Timeframe ---
 
+
 def lab_latest_categorical_match_in_timeframe(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if any categorical lab value in timeframe matches requirement.string_value.
     Timeframe in requirement.numeric_value_min/max.
     """
     patient_lab_values = input_links.patient_lab_values
-    if (not requirement.lab_values.exists() or
-        requirement.string_value is None or
-        requirement.numeric_value_min is None or
-        requirement.numeric_value_max is None):
+    if (
+        not requirement.lab_values.exists()
+        or requirement.string_value is None
+        or requirement.numeric_value_min is None
+        or requirement.numeric_value_max is None
+    ):
         return False
 
     match_string = requirement.string_value
@@ -480,25 +571,30 @@ def lab_latest_categorical_match_in_timeframe(
             patient_lab_values, lab_value_model.name, days_min, days_max
         )
         for plv in values_in_timeframe:
-            if hasattr(plv, 'value_str') and plv.value_str is not None: # Changed value_string to value_str
+            if (
+                hasattr(plv, "value_str") and plv.value_str is not None
+            ):  # Changed value_string to value_str
                 if plv.value_str == match_string:
                     return True
     return False
 
+
 def lab_latest_categorical_match_substring_in_timeframe(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if requirement.string_value is substring of any categorical lab value in timeframe.
     Timeframe in requirement.numeric_value_min/max.
     """
     patient_lab_values = input_links.patient_lab_values
-    if (not requirement.lab_values.exists() or
-        requirement.string_value is None or
-        requirement.numeric_value_min is None or
-        requirement.numeric_value_max is None):
+    if (
+        not requirement.lab_values.exists()
+        or requirement.string_value is None
+        or requirement.numeric_value_min is None
+        or requirement.numeric_value_max is None
+    ):
         return False
 
     substring = requirement.string_value
@@ -510,25 +606,30 @@ def lab_latest_categorical_match_substring_in_timeframe(
             patient_lab_values, lab_value_model.name, days_min, days_max
         )
         for plv in values_in_timeframe:
-            if hasattr(plv, 'value_str') and plv.value_str is not None: # Changed value_string to value_str
+            if (
+                hasattr(plv, "value_str") and plv.value_str is not None
+            ):  # Changed value_string to value_str
                 if substring in plv.value_str:
                     return True
     return False
 
+
 def lab_latest_categorical_match_regex_in_timeframe(
     input_links: "RequirementLinks",
     requirement: Requirement,
-    operator_kwargs: Dict[str, Any]
+    operator_kwargs: Dict[str, Any],
 ) -> bool:
     """
     Checks if any categorical lab value in timeframe matches regex in requirement.string_value.
     Timeframe in requirement.numeric_value_min/max.
     """
     patient_lab_values = input_links.patient_lab_values
-    if (not requirement.lab_values.exists() or
-        requirement.string_value is None or
-        requirement.numeric_value_min is None or
-        requirement.numeric_value_max is None):
+    if (
+        not requirement.lab_values.exists()
+        or requirement.string_value is None
+        or requirement.numeric_value_min is None
+        or requirement.numeric_value_max is None
+    ):
         return False
 
     regex_pattern = requirement.string_value
@@ -545,7 +646,9 @@ def lab_latest_categorical_match_regex_in_timeframe(
             patient_lab_values, lab_value_model.name, days_min, days_max
         )
         for plv in values_in_timeframe:
-            if hasattr(plv, 'value_str') and plv.value_str is not None: # Changed value_string to value_str
+            if (
+                hasattr(plv, "value_str") and plv.value_str is not None
+            ):  # Changed value_string to value_str
                 if compiled_regex.search(plv.value_str):
                     return True
     return False
@@ -558,17 +661,14 @@ LAB_VALUE_OPERATOR_FUNCTIONS: Dict[str, Callable] = {
     "lab_latest_numeric_normal": lab_latest_numeric_normal,
     "lab_latest_numeric_lower_than_value": lab_latest_numeric_lower_than_value,
     "lab_latest_numeric_greater_than_value": lab_latest_numeric_greater_than_value,
-
     # Aliases for backward compatibility, pointing to timeframe versions
     "lab_latest_numeric_increased_factor": lab_latest_numeric_increased_factor_in_timeframe,
     "lab_latest_numeric_decreased_factor": lab_latest_numeric_decreased_factor_in_timeframe,
-
     "lab_latest_numeric_increased_factor_in_timeframe": lab_latest_numeric_increased_factor_in_timeframe,
     "lab_latest_numeric_decreased_factor_in_timeframe": lab_latest_numeric_decreased_factor_in_timeframe,
     "lab_latest_numeric_normal_in_timeframe": lab_latest_numeric_normal_in_timeframe,
     "lab_latest_numeric_lower_than_value_in_timeframe": lab_latest_numeric_lower_than_value_in_timeframe,
     "lab_latest_numeric_greater_than_value_in_timeframe": lab_latest_numeric_greater_than_value_in_timeframe,
-
     "lab_latest_categorical_match": lab_latest_categorical_match,
     "lab_latest_categorical_match_substring": lab_latest_categorical_match_substring,
     "lab_latest_categorical_match_regex": lab_latest_categorical_match_regex,