Rename *Pair classes to *Set

rzats · rzats · commit 72f9cb8a4a80 · 2022-12-22T14:33:01.000+02:00
diff --git a/src/server/_params.py b/src/server/_params.py
@@ -48,7 +48,7 @@ def _parse_single_arg(key: str) -> Tuple[str, str]:
 
 
 @dataclass
-class GeoPair:
+class GeoSet:
     geo_type: str
     geo_values: Union[bool, Sequence[str]]
 
@@ -64,20 +64,20 @@ def count(self) -> float:
         return len(self.geo_values)
 
 
-def parse_geo_arg(key: str = "geo") -> List[GeoPair]:
-    return [GeoPair(geo_type, geo_values) for [geo_type, geo_values] in _parse_common_multi_arg(key)]
+def parse_geo_arg(key: str = "geo") -> List[GeoSet]:
+    return [GeoSet(geo_type, geo_values) for [geo_type, geo_values] in _parse_common_multi_arg(key)]
 
 
-def parse_single_geo_arg(key: str) -> GeoPair:
+def parse_single_geo_arg(key: str) -> GeoSet:
     """
     parses a single geo pair with only one value
     """
     r = _parse_single_arg(key)
-    return GeoPair(r[0], [r[1]])
+    return GeoSet(r[0], [r[1]])
 
 
 @dataclass
-class SourceSignalPair:
+class SourceSignalSet:
     source: str
     signal: Union[bool, Sequence[str]]
 
@@ -93,20 +93,20 @@ def count(self) -> float:
         return len(self.signal)
 
 
-def parse_source_signal_arg(key: str = "signal") -> List[SourceSignalPair]:
-    return [SourceSignalPair(source, signals) for [source, signals] in _parse_common_multi_arg(key)]
+def parse_source_signal_arg(key: str = "signal") -> List[SourceSignalSet]:
+    return [SourceSignalSet(source, signals) for [source, signals] in _parse_common_multi_arg(key)]
 
 
-def parse_single_source_signal_arg(key: str) -> SourceSignalPair:
+def parse_single_source_signal_arg(key: str) -> SourceSignalSet:
     """
     parses a single source signal pair with only one value
     """
     r = _parse_single_arg(key)
-    return SourceSignalPair(r[0], [r[1]])
+    return SourceSignalSet(r[0], [r[1]])
 
 
 @dataclass
-class TimePair:
+class TimeSet:
     time_type: str
     time_values: Union[bool, TimeValues]
 
@@ -134,10 +134,10 @@ def to_ranges(self):
         returns this pair with times converted to ranges
         """
         if isinstance(self.time_values, bool):
-            return TimePair(self.time_type, self.time_values)
+            return TimeSet(self.time_type, self.time_values)
         if self.time_type == 'week':
-            return TimePair(self.time_type, weeks_to_ranges(self.time_values))
-        return TimePair(self.time_type, days_to_ranges(self.time_values))
+            return TimeSet(self.time_type, weeks_to_ranges(self.time_values))
+        return TimeSet(self.time_type, days_to_ranges(self.time_values))
 
 
 def _verify_range(start: int, end: int) -> Union[int, Tuple[int, int]]:
@@ -204,18 +204,18 @@ def parse_day_value(time_value: str) -> Union[int, Tuple[int, int]]:
     raise ValidationFailedException(msg)
 
 
-def _parse_time_pair(time_type: str, time_values: Union[bool, Sequence[str]]) -> TimePair:
+def _parse_time_pair(time_type: str, time_values: Union[bool, Sequence[str]]) -> TimeSet:
     if isinstance(time_values, bool):
-        return TimePair(time_type, time_values)
+        return TimeSet(time_type, time_values)
 
     if time_type == "week":
-        return TimePair("week", [parse_week_value(t) for t in time_values])
+        return TimeSet("week", [parse_week_value(t) for t in time_values])
     elif time_type == "day":
-        return TimePair("day", [parse_day_value(t) for t in time_values])
+        return TimeSet("day", [parse_day_value(t) for t in time_values])
     raise ValidationFailedException(f'time param: {time_type} is not one of "day" or "week"')
 
 
-def parse_time_arg(key: str = "time") -> Optional[TimePair]:
+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)]
 
     # single value
@@ -236,10 +236,10 @@ def parse_time_arg(key: str = "time") -> Optional[TimePair]:
             return time_pair
         else:
             merged.extend(time_pair.time_values)
-    return TimePair(time_pairs[0].time_type, merged).to_ranges()
+    return TimeSet(time_pairs[0].time_type, merged).to_ranges()
 
 
-def parse_single_time_arg(key: str) -> TimePair:
+def parse_single_time_arg(key: str) -> TimeSet:
     """
     parses a single time pair with only one value
     """
@@ -285,26 +285,26 @@ def parse_week_range_arg(key: str) -> Tuple[int, int]:
         raise ValidationFailedException(f"{key} must match YYYYWW-YYYYWW")
     return r
 
-def parse_day_or_week_arg(key: str, default_value: Optional[int] = None) -> TimePair:
+def parse_day_or_week_arg(key: str, default_value: Optional[int] = None) -> TimeSet:
     v = request.values.get(key)
     if not v:
         if default_value is not None:
             time_type = "day" if guess_time_value_is_day(default_value) else "week"
-            return TimePair(time_type, [default_value])
+            return TimeSet(time_type, [default_value])
         raise ValidationFailedException(f"{key} param is required")
     # format is either YYYY-MM-DD or YYYYMMDD or YYYYMM
     is_week = guess_time_value_is_week(v)
     if is_week:
-        return TimePair("week", [parse_week_arg(key)])
-    return TimePair("day", [parse_day_arg(key)])
+        return TimeSet("week", [parse_week_arg(key)])
+    return TimeSet("day", [parse_day_arg(key)])
 
-def parse_day_or_week_range_arg(key: str) -> TimePair:
+def parse_day_or_week_range_arg(key: str) -> TimeSet:
     v = request.values.get(key)
     if not v:
         raise ValidationFailedException(f"{key} param is required")
     # format is either YYYY-MM-DD--YYYY-MM-DD or YYYYMMDD-YYYYMMDD or YYYYMM-YYYYMM
     # so if the first before the - has length 6, it must be a week
     is_week = guess_time_value_is_week(v.split('-', 2)[0])
     if is_week:
-        return TimePair("week", [parse_week_range_arg(key)])
-    return TimePair("day", [parse_day_range_arg(key)])
+        return TimeSet("week", [parse_week_range_arg(key)])
+    return TimeSet("day", [parse_day_range_arg(key)])
diff --git a/src/server/_query.py b/src/server/_query.py
@@ -19,7 +19,7 @@
 from ._printer import create_printer, APrinter
 from ._exceptions import DatabaseErrorException
 from ._validate import extract_strings
-from ._params import GeoPair, SourceSignalPair, TimePair
+from ._params import GeoSet, SourceSignalSet, TimeSet
 from .utils import time_values_to_ranges, TimeValues
 
 
@@ -118,15 +118,15 @@ def filter_fields(generator: Iterable[Dict[str, Any]]):
 def filter_geo_pairs(
     type_field: str,
     value_field: str,
-    values: Sequence[GeoPair],
+    values: Sequence[GeoSet],
     param_key: str,
     params: Dict[str, Any],
 ) -> str:
     """
     returns the SQL sub query to filter by the given geo pairs
     """
 
-    def filter_pair(pair: GeoPair, i) -> str:
+    def filter_pair(pair: 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:
@@ -145,15 +145,15 @@ def filter_pair(pair: GeoPair, i) -> str:
 def filter_source_signal_pairs(
     source_field: str,
     signal_field: str,
-    values: Sequence[SourceSignalPair],
+    values: Sequence[SourceSignalSet],
     param_key: str,
     params: Dict[str, Any],
 ) -> str:
     """
     returns the SQL sub query to filter by the given source signal pairs
     """
 
-    def filter_pair(pair: SourceSignalPair, i) -> str:
+    def filter_pair(pair: SourceSignalSet, i) -> str:
         source_param = f"{param_key}_{i}t"
         params[source_param] = pair.source
         if isinstance(pair.signal, bool) and pair.signal:
@@ -172,7 +172,7 @@ def filter_pair(pair: SourceSignalPair, i) -> str:
 def filter_time_pair(
     type_field: str,
     time_field: str,
-    pair: Optional[TimePair],
+    pair: Optional[TimeSet],
     param_key: str,
     params: Dict[str, Any],
 ) -> str:
@@ -410,7 +410,7 @@ def where_geo_pairs(
         self,
         type_field: str,
         value_field: str,
-        values: Sequence[GeoPair],
+        values: Sequence[GeoSet],
         param_key: Optional[str] = None,
     ) -> "QueryBuilder":
         fq_type_field = self._fq_field(type_field)
@@ -430,7 +430,7 @@ def where_source_signal_pairs(
         self,
         type_field: str,
         value_field: str,
-        values: Sequence[SourceSignalPair],
+        values: Sequence[SourceSignalSet],
         param_key: Optional[str] = None,
     ) -> "QueryBuilder":
         fq_type_field = self._fq_field(type_field)
@@ -450,7 +450,7 @@ def where_time_pair(
         self,
         type_field: str,
         value_field: str,
-        values: Optional[TimePair],
+        values: Optional[TimeSet],
         param_key: Optional[str] = None,
     ) -> "QueryBuilder":
         fq_type_field = self._fq_field(type_field)
diff --git a/src/server/endpoints/covidcast.py b/src/server/endpoints/covidcast.py
@@ -11,9 +11,9 @@
 from .._common import is_compatibility_mode, db
 from .._exceptions import ValidationFailedException, DatabaseErrorException
 from .._params import (
-    GeoPair,
-    SourceSignalPair,
-    TimePair,
+    GeoSet,
+    SourceSignalSet,
+    TimeSet,
     parse_geo_arg,
     parse_source_signal_arg,
     parse_time_arg,
@@ -45,45 +45,45 @@
 latest_table = "epimetric_latest_v"
 history_table = "epimetric_full_v"
 
-def parse_source_signal_pairs() -> List[SourceSignalPair]:
+def parse_source_signal_pairs() -> List[SourceSignalSet]:
     ds = request.values.get("data_source")
     if ds:
         # old version
         require_any("signal", "signals", empty=True)
         signals = extract_strings(("signals", "signal"))
         if len(signals) == 1 and signals[0] == "*":
-            return [SourceSignalPair(ds, True)]
-        return [SourceSignalPair(ds, signals)]
+            return [SourceSignalSet(ds, True)]
+        return [SourceSignalSet(ds, signals)]
 
     if ":" not in request.values.get("signal", ""):
         raise ValidationFailedException("missing parameter: signal or (data_source and signal[s])")
 
     return parse_source_signal_arg()
 
 
-def parse_geo_pairs() -> List[GeoPair]:
+def parse_geo_pairs() -> List[GeoSet]:
     geo_type = request.values.get("geo_type")
     if geo_type:
         # old version
         require_any("geo_value", "geo_values", empty=True)
         geo_values = extract_strings(("geo_values", "geo_value"))
         if len(geo_values) == 1 and geo_values[0] == "*":
-            return [GeoPair(geo_type, True)]
-        return [GeoPair(geo_type, geo_values)]
+            return [GeoSet(geo_type, True)]
+        return [GeoSet(geo_type, geo_values)]
 
     if ":" not in request.values.get("geo", ""):
         raise ValidationFailedException("missing parameter: geo or (geo_type and geo_value[s])")
 
     return parse_geo_arg()
 
 
-def parse_time_pairs() -> TimePair:
+def parse_time_pairs() -> TimeSet:
     time_type = request.values.get("time_type")
     if time_type:
         # old version
         require_all("time_type", "time_values")
         time_values = extract_dates("time_values")
-        return TimePair(time_type, time_values)
+        return TimeSet(time_type, time_values)
 
     if ":" not in request.values.get("time", ""):
         raise ValidationFailedException("missing parameter: time or (time_type and time_values)")
@@ -356,7 +356,7 @@ def gen():
 @bp.route("/csv", methods=("GET", "POST"))
 def handle_export():
     source, signal = request.values.get("signal", "jhu-csse:confirmed_incidence_num").split(":")
-    source_signal_pairs = [SourceSignalPair(source, [signal])]
+    source_signal_pairs = [SourceSignalSet(source, [signal])]
     daily_signals, weekly_signals = count_signal_time_types(source_signal_pairs)
     source_signal_pairs, alias_mapper = create_source_signal_alias_mapper(source_signal_pairs)
     start_pair = parse_day_or_week_arg("start_day", 202001 if weekly_signals > 0 else 20200401)
@@ -383,8 +383,8 @@ def handle_export():
     q.set_fields(["geo_value", "signal", "time_value", "issue", "lag", "value", "stderr", "sample_size", "geo_type", "source"], [], [])
     q.set_order("time_value", "geo_value")
     q.where_source_signal_pairs("source", "signal", source_signal_pairs)
-    q.where_time_pair("time_type", "time_value", TimePair("day" if is_day else "week", [(start_day, end_day)]))
-    q.where_geo_pairs("geo_type", "geo_value", [GeoPair(geo_type, True if geo_values == "*" else geo_values)])
+    q.where_time_pair("time_type", "time_value", TimeSet("day" if is_day else "week", [(start_day, end_day)]))
+    q.where_geo_pairs("geo_type", "geo_value", [GeoSet(geo_type, True if geo_values == "*" else geo_values)])
 
     _handle_lag_issues_as_of(q, None, None, as_of)
 
@@ -615,13 +615,13 @@ def handle_coverage():
                 last_weeks = last or 30
             is_day = False
             now_week = Week.thisweek() if now_time is None else time_value_to_week(now_time)
-            time_window = TimePair("week", [(week_to_time_value(now_week - last_weeks), week_to_time_value(now_week))])
+            time_window = TimeSet("week", [(week_to_time_value(now_week - last_weeks), week_to_time_value(now_week))])
         else:
             is_day = True
             if last is None:
                 last = 30
             now = date.today() if now_time is None else time_value_to_day(now_time)
-            time_window = TimePair("day", [(day_to_time_value(now - timedelta(days=last)), day_to_time_value(now))])
+            time_window = TimeSet("day", [(day_to_time_value(now - timedelta(days=last)), day_to_time_value(now))])
     _verify_argument_time_type_matches(is_day, daily_signals, weekly_signals)
 
     q = QueryBuilder(latest_table, "c")
diff --git a/src/server/endpoints/covidcast_utils/model.py b/src/server/endpoints/covidcast_utils/model.py
@@ -6,7 +6,7 @@
 import pandas as pd
 import numpy as np
 
-from ..._params import SourceSignalPair
+from ..._params import SourceSignalSet
 
 
 class HighValuesAre(str, Enum):
@@ -241,7 +241,7 @@ def get_related_signals(signal: DataSignal) -> List[DataSignal]:
     return [s for s in data_signals if s != signal and s.signal_basename == signal.signal_basename]
 
 
-def count_signal_time_types(source_signals: List[SourceSignalPair]) -> Tuple[int, int]:
+def count_signal_time_types(source_signals: List[SourceSignalSet]) -> Tuple[int, int]:
     """
     count the number of signals in this query for each time type
     @returns daily counts, weekly counts
@@ -262,9 +262,9 @@ def count_signal_time_types(source_signals: List[SourceSignalPair]) -> Tuple[int
     return daily, weekly
 
 
-def create_source_signal_alias_mapper(source_signals: List[SourceSignalPair]) -> Tuple[List[SourceSignalPair], Optional[Callable[[str, str], str]]]:
+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_pairs: List[SourceSignalPair] = []
+    transformed_pairs: List[SourceSignalSet] = []
     for pair in source_signals:
         source = data_source_by_id.get(pair.source)
         if not source or not source.uses_db_alias:
@@ -274,9 +274,9 @@ def create_source_signal_alias_mapper(source_signals: List[SourceSignalPair]) ->
         alias_to_data_sources.setdefault(source.db_source, []).append(source)
         if pair.signal is True:
             # list all signals of this source (*) so resolve to a plain list of all in this alias
-            transformed_pairs.append(SourceSignalPair(source.db_source, [s.signal for s in source.signals]))
+            transformed_pairs.append(SourceSignalSet(source.db_source, [s.signal for s in source.signals]))
         else:
-            transformed_pairs.append(SourceSignalPair(source.db_source, pair.signal))
+            transformed_pairs.append(SourceSignalSet(source.db_source, pair.signal))
 
     if not alias_to_data_sources:
         # no alias needed
diff --git a/tests/server/endpoints/test_covidcast.py b/tests/server/endpoints/test_covidcast.py
@@ -5,11 +5,6 @@
 from flask import Response
 from delphi.epidata.server.main import app
 
-from delphi.epidata.server._params import (
-    GeoPair,
-    TimePair,
-)
-
 # py3tester coverage target
 __test_target__ = "delphi.epidata.server.endpoints.covidcast"
 
diff --git a/tests/server/test_params.py b/tests/server/test_params.py
diff --git a/tests/server/test_query.py b/tests/server/test_query.py
