Address review comments

Author: rzats

src/server/_query.py

@@ -126,12 +126,12 @@ def filter_geo_sets(
     returns the SQL sub query to filter by the given geo sets
     """
 
-    def filter_set(set: GeoSet, i) -> str:
+    def filter_set(gset: GeoSet, i) -> str:
         type_param = f"{param_key}_{i}t"
-        params[type_param] = set.geo_type
-        if isinstance(set.geo_values, bool) and set.geo_values:
+        params[type_param] = gset.geo_type
+        if isinstance(gset.geo_values, bool) and gset.geo_values:
             return f"{type_field} = :{type_param}"
-        return f"({type_field} = :{type_param} AND {filter_strings(value_field, cast(Sequence[str], set.geo_values), type_param, params)})"
+        return f"({type_field} = :{type_param} AND {filter_strings(value_field, cast(Sequence[str], gset.geo_values), type_param, params)})"
 
     parts = [filter_set(p, i) for i, p in enumerate(values)]
 
@@ -153,12 +153,12 @@ def filter_source_signal_sets(
     returns the SQL sub query to filter by the given source signal sets
     """
 
-    def filter_set(set: SourceSignalSet, i) -> str:
+    def filter_set(ssset: SourceSignalSet, i) -> str:
         source_param = f"{param_key}_{i}t"
-        params[source_param] = set.source
-        if isinstance(set.signal, bool) and set.signal:
+        params[source_param] = ssset.source
+        if isinstance(ssset.signal, bool) and ssset.signal:
             return f"{source_field} = :{source_param}"
-        return f"({source_field} = :{source_param} AND {filter_strings(signal_field, cast(Sequence[str], set.signal), source_param, params)})"
+        return f"({source_field} = :{source_param} AND {filter_strings(signal_field, cast(Sequence[str], ssset.signal), source_param, params)})"
 
     parts = [filter_set(p, i) for i, p in enumerate(values)]
 
@@ -172,23 +172,23 @@ def filter_set(set: SourceSignalSet, i) -> str:
 def filter_time_set(
     type_field: str,
     time_field: str,
-    set: Optional[TimeSet],
+    tset: Optional[TimeSet],
     param_key: str,
     params: Dict[str, Any],
 ) -> str:
     """
     returns the SQL sub query to filter by the given time set
     """
     # safety path; should normally not be reached as time sets are enforced by the API
-    if not set:
+    if not tset:
         return "FALSE"
 
     type_param = f"{param_key}_0t"
-    params[type_param] = set.time_type
-    if isinstance(set.time_values, bool) and set.time_values:
+    params[type_param] = tset.time_type
+    if isinstance(tset.time_values, bool) and tset.time_values:
         parts =  f"{type_field} = :{type_param}"
     else:
-        ranges = set.to_ranges().time_values
+        ranges = tset.to_ranges().time_values
         parts = f"({type_field} = :{type_param} AND {filter_integers(time_field, ranges, type_param, params)})"
 
     return f"({parts})"

src/server/endpoints/covidcast_utils/model.py

@@ -248,11 +248,11 @@ def count_signal_time_types(source_signals: List[SourceSignalSet]) -> Tuple[int,
     """
     weekly = 0
     daily = 0
-    for set in source_signals:
-        if set.signal == True:
+    for ssset in source_signals:
+        if ssset.signal == True:
             continue
-        for s in set.signal:
-            signal = data_signals_by_key.get((set.source, s))
+        for s in ssset.signal:
+            signal = data_signals_by_key.get((ssset.source, s))
             if not signal:
                 continue
             if signal.time_type == TimeType.week:
@@ -265,18 +265,18 @@ def count_signal_time_types(source_signals: List[SourceSignalSet]) -> Tuple[int,
 def create_source_signal_alias_mapper(source_signals: List[SourceSignalSet]) -> Tuple[List[SourceSignalSet], Optional[Callable[[str, str], str]]]:
     alias_to_data_sources: Dict[str, List[DataSource]] = {}
     transformed_sets: List[SourceSignalSet] = []
-    for set in source_signals:
-        source = data_source_by_id.get(set.source)
+    for ssset in source_signals:
+        source = data_source_by_id.get(ssset.source)
         if not source or not source.uses_db_alias:
-            transformed_sets.append(set)
+            transformed_sets.append(ssset)
             continue
         # uses an alias
         alias_to_data_sources.setdefault(source.db_source, []).append(source)
-        if set.signal is True:
+        if ssset.signal is True:
             # list all signals of this source (*) so resolve to a plain list of all in this alias
             transformed_sets.append(SourceSignalSet(source.db_source, [s.signal for s in source.signals]))
         else:
-            transformed_sets.append(SourceSignalSet(source.db_source, set.signal))
+            transformed_sets.append(SourceSignalSet(source.db_source, ssset.signal))
 
     if not alias_to_data_sources:
         # no alias needed