refactor naming for x to compare and z to control

Author: Moritz-Alexander-Kern

neo/core/filters.py

@@ -33,23 +33,23 @@ class FilterCondition(ABC):
         segment=filter({'my_annotation': <FilterCondition>})
     """
     @abstractmethod
-    def __init__(self, z) -> None:
+    def __init__(self, control: Any) -> None:
         """
         Initialize new FilterCondition object.
 
         Parameters:
-            z: Any - The control value to be used for filtering.
+            control: Any - The control value to be used for filtering.
 
         This is an abstract base class and should not be instantiated directly.
         """
 
     @abstractmethod
-    def evaluate(self, x):
+    def evaluate(self, compare: Any) -> bool:
         """
         Evaluate the filter condition for given value.
 
         Parameters:
-            x: Any - The value to be compared with the control value.
+            compare: Any - The value to be compared with the control value.
 
         Returns:
             bool: True if the condition is satisfied, False otherwise.
@@ -62,80 +62,80 @@ class Equals(FilterCondition):
     """
     Filter condition to check if target value is equal to the control value.
     """
-    def __init__(self, z: Any) -> None:
-        self.control = z
+    def __init__(self, control: Any) -> None:
+        self.control = control
 
-    def evaluate(self, x: Any) -> bool:
-        return x == self.control
+    def evaluate(self, compare: Any) -> bool:
+        return compare == self.control
 
 
 class IsNot(FilterCondition):
     """
     Filter condition to check if target value is not equal to the control value.
     """
-    def __init__(self, z: Any) -> None:
-        self.control = z
+    def __init__(self, control: Any) -> None:
+        self.control = control
 
-    def evaluate(self, x: Any) -> bool:
-        return x != self.control
+    def evaluate(self, compare: Any) -> bool:
+        return compare != self.control
 
 
 class LessThanOrEquals(FilterCondition):
     """
     Filter condition to check if target value is less than or equal to the control value.
     """
-    def __init__(self, z: Number) -> None:
-        self.control = z
+    def __init__(self, control: Number) -> None:
+        self.control = control
 
-    def evaluate(self, x: Number) -> bool:
-        return x <= self.control
+    def evaluate(self, compare: Number) -> bool:
+        return compare <= self.control
 
 
 class GreaterThanOrEquals(FilterCondition):
     """
     Filter condition to check if target value is greater than or equal to the control value.
     """
-    def __init__(self, z: Number) -> None:
-        self.control = z
+    def __init__(self, control: Number) -> None:
+        self.control = control
 
-    def evaluate(self, x: Number) -> bool:
-        return x >= self.control
+    def evaluate(self, compare: Number) -> bool:
+        return compare >= self.control
 
 
 class LessThan(FilterCondition):
     """
     Filter condition to check if target value is less than the control value.
     """
-    def __init__(self, z: Number) -> None:
-        self.control = z
+    def __init__(self, control: Number) -> None:
+        self.control = control
 
-    def evaluate(self, x: Number) -> bool:
-        return x < self.control
+    def evaluate(self, compare: Number) -> bool:
+        return compare < self.control
 
 
 class GreaterThan(FilterCondition):
     """
     Filter condition to check if target value is greater than the control value.
     """
-    def __init__(self, z: Number) -> None:
-        self.control = z
+    def __init__(self, control: Number) -> None:
+        self.control = control
 
-    def evaluate(self, x: Number) -> bool:
-        return x > self.control
+    def evaluate(self, compare: Number) -> bool:
+        return compare > self.control
 
 
 class IsIn(FilterCondition):
     """
     Filter condition to check if target is in control.
     """
-    def __init__(self, z: Union[list, tuple, set, int]) -> None:
-        self.control = z
+    def __init__(self, control: Union[list, tuple, set, int]) -> None:
+        self.control = control
 
-    def evaluate(self, x: Any) -> bool:
+    def evaluate(self, compare: Any) -> bool:
         if isinstance(self.control, (list, tuple, set)):
-            return x in self.control
+            return compare in self.control
         if isinstance(self.control, int):
-            return x == self.control
+            return compare == self.control
 
         raise SyntaxError('parameter not of type list, tuple, set or int')
 
@@ -150,8 +150,8 @@ class InRange(FilterCondition):
     Parameters:
         lower_bound: int - The lower bound of the range.
         upper_bound: int - The upper bound of the range.
-        left_closed: bool - If True, the range includes the lower bound (lower_bound <= x).
-        right_closed: bool - If True, the range includes the upper bound (x <= upper_bound).
+        left_closed: bool - If True, the range includes the lower bound (lower_bound <= compare).
+        right_closed: bool - If True, the range includes the upper bound (compare <= upper_bound).
     """
     def __init__(self, lower_bound: Number, upper_bound: Number,
                  left_closed: bool=False, right_closed: bool=False) -> None:
@@ -163,11 +163,11 @@ def __init__(self, lower_bound: Number, upper_bound: Number,
         self.left_closed = left_closed
         self.right_closed = right_closed
 
-    def evaluate(self, x: Number) -> bool:
+    def evaluate(self, compare: Number) -> bool:
         if not self.left_closed and not self.right_closed:
-            return self.lower_bound <= x <= self.upper_bound
+            return self.lower_bound <= compare <= self.upper_bound
         if not self.left_closed and self.right_closed:
-            return self.lower_bound <= x < self.upper_bound
+            return self.lower_bound <= compare < self.upper_bound
         if self.left_closed and not self.right_closed:
-            return self.lower_bound < x <= self.upper_bound
-        return self.lower_bound < x < self.upper_bound
+            return self.lower_bound < compare <= self.upper_bound
+        return self.lower_bound < compare < self.upper_bound