API server code health pass - rename *Pair classes to *Set

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]]
 
@@ -57,27 +57,27 @@ 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
         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
+    parses a single geo set 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]]
 
@@ -86,27 +86,27 @@ 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
         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
+    parses a single source signal set 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]
 
@@ -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,13 +131,13 @@ 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 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) -> IntRange:
@@ -204,47 +204,47 @@ def parse_day_value(time_value: str) -> IntRange:
     raise ValidationFailedException(msg)
 
 
-def _parse_time_pair(time_type: str, time_values: Union[bool, Sequence[str]]) -> TimePair:
+def _parse_time_set(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]:
-    time_pairs = [_parse_time_pair(time_type, time_values) for [time_type, time_values] in _parse_common_multi_arg(key)]
+def parse_time_arg(key: str = "time") -> Optional[TimeSet]:
+    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 TimePair(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) -> TimePair:
+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]:
@@ -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)])