Rename related methods & tests

Author: rzats

src/server/_params.py

@@ -57,7 +57,7 @@ def matches(self, geo_type: str, geo_value: str) -> bool:
 
     def count(self) -> float:
         """
-        returns the count of items in this pair
+        returns the count of items in this set
         """
         if isinstance(self.geo_values, bool):
             return inf if self.geo_values else 0
@@ -70,7 +70,7 @@ def parse_geo_arg(key: str = "geo") -> List[GeoSet]:
 
 def parse_single_geo_arg(key: str) -> GeoSet:
     """
-    parses a single geo pair with only one value
+    parses a single geo set with only one value
     """
     r = _parse_single_arg(key)
     return GeoSet(r[0], [r[1]])
@@ -86,7 +86,7 @@ def matches(self, source: str, signal: str) -> bool:
 
     def count(self) -> float:
         """
-        returns the count of items in this pair
+        returns the count of items in this set
         """
         if isinstance(self.signal, bool):
             return inf if self.signal else 0
@@ -99,7 +99,7 @@ def parse_source_signal_arg(key: str = "signal") -> List[SourceSignalSet]:
 
 def parse_single_source_signal_arg(key: str) -> SourceSignalSet:
     """
-    parses a single source signal pair with only one value
+    parses a single source signal set with only one value
     """
     r = _parse_single_arg(key)
     return SourceSignalSet(r[0], [r[1]])
@@ -121,7 +121,7 @@ def is_day(self) -> bool:
 
     def count(self) -> float:
         """
-        returns the count of items in this pair
+        returns the count of items in this set
         """
         if isinstance(self.time_values, bool):
             return inf if self.time_values else 0
@@ -131,7 +131,7 @@ def count(self) -> float:
 
     def to_ranges(self):
         """
-        returns this pair with times converted to ranges
+        returns this set with times converted to ranges
         """
         if isinstance(self.time_values, bool):
             return TimeSet(self.time_type, self.time_values)
@@ -204,7 +204,7 @@ def parse_day_value(time_value: str) -> IntRange:
     raise ValidationFailedException(msg)
 
 
-def _parse_time_pair(time_type: str, time_values: Union[bool, Sequence[str]]) -> TimeSet:
+def _parse_time_set(time_type: str, time_values: Union[bool, Sequence[str]]) -> TimeSet:
     if isinstance(time_values, bool):
         return TimeSet(time_type, time_values)
 
@@ -216,35 +216,35 @@ def _parse_time_pair(time_type: str, time_values: Union[bool, Sequence[str]]) ->
 
 
 def parse_time_arg(key: str = "time") -> Optional[TimeSet]:
-    time_pairs = [_parse_time_pair(time_type, time_values) for [time_type, time_values] in _parse_common_multi_arg(key)]
+    time_sets = [_parse_time_set(time_type, time_values) for [time_type, time_values] in _parse_common_multi_arg(key)]
 
     # single value
-    if len(time_pairs) == 0:
+    if len(time_sets) == 0:
         return None
-    if len(time_pairs) == 1:
-        return time_pairs[0]
+    if len(time_sets) == 1:
+        return time_sets[0]
 
     # make sure 'day' and 'week' aren't mixed
-    time_types = set(time_pair.time_type for time_pair in time_pairs)
+    time_types = set(time_set.time_type for time_set in time_sets)
     if len(time_types) >= 2:
-        raise ValidationFailedException(f'{key}: {time_pairs} mixes "day" and "week" time types')
+        raise ValidationFailedException(f'{key}: {time_sets} mixes "day" and "week" time types')
 
-    # merge all time pairs into one
+    # merge all time sets into one
     merged = []
-    for time_pair in time_pairs:
-        if time_pair.time_values is True:
-            return time_pair
+    for time_set in time_sets:
+        if time_set.time_values is True:
+            return time_set
         else:
-            merged.extend(time_pair.time_values)
-    return TimeSet(time_pairs[0].time_type, merged).to_ranges()
+            merged.extend(time_set.time_values)
+    return TimeSet(time_sets[0].time_type, merged).to_ranges()
 
 
 def parse_single_time_arg(key: str) -> TimeSet:
     """
-    parses a single time pair with only one value
+    parses a single time set with only one value
     """
     r = _parse_single_arg(key)
-    return _parse_time_pair(r[0], [r[1]])
+    return _parse_time_set(r[0], [r[1]])
 
 
 def parse_day_range_arg(key: str) -> Tuple[int, int]:

src/server/_query.py

@@ -115,25 +115,25 @@ def filter_fields(generator: Iterable[Dict[str, Any]]):
             yield filtered
 
 
-def filter_geo_pairs(
+def filter_geo_sets(
     type_field: str,
     value_field: str,
     values: Sequence[GeoSet],
     param_key: str,
     params: Dict[str, Any],
 ) -> str:
     """
-    returns the SQL sub query to filter by the given geo pairs
+    returns the SQL sub query to filter by the given geo sets
     """
 
-    def filter_pair(pair: GeoSet, i) -> str:
+    def filter_set(set: GeoSet, i) -> str:
         type_param = f"{param_key}_{i}t"
-        params[type_param] = pair.geo_type
-        if isinstance(pair.geo_values, bool) and pair.geo_values:
+        params[type_param] = set.geo_type
+        if isinstance(set.geo_values, bool) and set.geo_values:
             return f"{type_field} = :{type_param}"
-        return f"({type_field} = :{type_param} AND {filter_strings(value_field, cast(Sequence[str], pair.geo_values), type_param, params)})"
+        return f"({type_field} = :{type_param} AND {filter_strings(value_field, cast(Sequence[str], set.geo_values), type_param, params)})"
 
-    parts = [filter_pair(p, i) for i, p in enumerate(values)]
+    parts = [filter_set(p, i) for i, p in enumerate(values)]
 
     if not parts:
         # something has to be selected
@@ -142,25 +142,25 @@ def filter_pair(pair: GeoSet, i) -> str:
     return f"({' OR '.join(parts)})"
 
 
-def filter_source_signal_pairs(
+def filter_source_signal_sets(
     source_field: str,
     signal_field: str,
     values: Sequence[SourceSignalSet],
     param_key: str,
     params: Dict[str, Any],
 ) -> str:
     """
-    returns the SQL sub query to filter by the given source signal pairs
+    returns the SQL sub query to filter by the given source signal sets
     """
 
-    def filter_pair(pair: SourceSignalSet, i) -> str:
+    def filter_set(set: SourceSignalSet, i) -> str:
         source_param = f"{param_key}_{i}t"
-        params[source_param] = pair.source
-        if isinstance(pair.signal, bool) and pair.signal:
+        params[source_param] = set.source
+        if isinstance(set.signal, bool) and set.signal:
             return f"{source_field} = :{source_param}"
-        return f"({source_field} = :{source_param} AND {filter_strings(signal_field, cast(Sequence[str], pair.signal), source_param, params)})"
+        return f"({source_field} = :{source_param} AND {filter_strings(signal_field, cast(Sequence[str], set.signal), source_param, params)})"
 
-    parts = [filter_pair(p, i) for i, p in enumerate(values)]
+    parts = [filter_set(p, i) for i, p in enumerate(values)]
 
     if not parts:
         # something has to be selected
@@ -169,26 +169,26 @@ def filter_pair(pair: SourceSignalSet, i) -> str:
     return f"({' OR '.join(parts)})"
 
 
-def filter_time_pair(
+def filter_time_set(
     type_field: str,
     time_field: str,
-    pair: Optional[TimeSet],
+    set: Optional[TimeSet],
     param_key: str,
     params: Dict[str, Any],
 ) -> str:
     """
-    returns the SQL sub query to filter by the given time pair
+    returns the SQL sub query to filter by the given time set
     """
-    # safety path; should normally not be reached as time pairs are enforced by the API
-    if not pair:
+    # safety path; should normally not be reached as time sets are enforced by the API
+    if not set:
         return "FALSE"
 
     type_param = f"{param_key}_0t"
-    params[type_param] = pair.time_type
-    if isinstance(pair.time_values, bool) and pair.time_values:
+    params[type_param] = set.time_type
+    if isinstance(set.time_values, bool) and set.time_values:
         parts =  f"{type_field} = :{type_param}"
     else:
-        ranges = pair.to_ranges().time_values
+        ranges = set.to_ranges().time_values
         parts = f"({type_field} = :{type_param} AND {filter_integers(time_field, ranges, type_param, params)})"
 
     return f"({parts})"
@@ -406,65 +406,62 @@ def where_integers(
         self.conditions.append(filter_integers(fq_field, values, param_key or field, self.params))
         return self
 
-    def where_geo_pairs(
+    def apply_geo_filters(
         self,
         type_field: str,
         value_field: str,
         values: Sequence[GeoSet],
-        param_key: Optional[str] = None,
-    ) -> "QueryBuilder":
+        param_key: Optional[str] = None
+    ):
         fq_type_field = self._fq_field(type_field)
         fq_value_field = self._fq_field(value_field)
         self.conditions.append(
-            filter_geo_pairs(
+            filter_geo_sets(
                 fq_type_field,
                 fq_value_field,
                 values,
                 param_key or type_field,
                 self.params,
             )
         )
-        return self
 
-    def where_source_signal_pairs(
+    def apply_source_signal_filters(
         self,
         type_field: str,
         value_field: str,
         values: Sequence[SourceSignalSet],
-        param_key: Optional[str] = None,
-    ) -> "QueryBuilder":
+        param_key: Optional[str] = None
+    ):
         fq_type_field = self._fq_field(type_field)
         fq_value_field = self._fq_field(value_field)
         self.conditions.append(
-            filter_source_signal_pairs(
+            filter_source_signal_sets(
                 fq_type_field,
                 fq_value_field,
                 values,
                 param_key or type_field,
                 self.params,
             )
         )
-        return self
 
-    def where_time_pair(
+    def apply_time_filter(
         self,
         type_field: str,
         value_field: str,
         values: Optional[TimeSet],
         param_key: Optional[str] = None,
-    ) -> "QueryBuilder":
+    ):
         fq_type_field = self._fq_field(type_field)
         fq_value_field = self._fq_field(value_field)
         self.conditions.append(
-            filter_time_pair(
+            filter_time_set(
                 fq_type_field,
                 fq_value_field,
                 values,
                 param_key or type_field,
                 self.params,
             )
         )
-        return self
 
     def apply_lag_filter(self, history_table: str, lag: Optional[int]):
         if lag is not None: