Removed existing T imports from utils and made T instances private (#183)

Made U instances private for consistency

Co-authored-by: Matt Wilhelm <[email protected]>
Co-authored-by: Keith Fung <[email protected]>

Author: 3 people

src/electionguard/data_store.py

@@ -12,26 +12,26 @@
 )
 
 
-T = TypeVar("T")
-U = TypeVar("U")
+_T = TypeVar("_T")
+_U = TypeVar("_U")
 
 
-class DataStore(Generic[T, U], Iterable):
+class DataStore(Generic[_T, _U], Iterable):
     """
     A lightweight convenience wrapper around a dictionary for data storage.
     This implementation defines the common interface used to access stored
     state elements.  
     """
 
-    _store: Dict[T, U]
+    _store: Dict[_T, _U]
 
     def __init__(self) -> None:
         self._store = {}
 
     def __iter__(self) -> Iterator:
         return iter(self._store.items())
 
-    def all(self) -> List[Optional[U]]:
+    def all(self) -> List[Optional[_U]]:
         """
         Get all `CiphertextAcceptedBallot` from the store
         """
@@ -43,22 +43,22 @@ def clear(self) -> None:
         """
         self._store.clear()
 
-    def get(self, key: T) -> Optional[U]:
+    def get(self, key: _T) -> Optional[_U]:
         """
         Get value in store
         :param key: key
         :return: value if found
         """
         return self._store.get(key)
 
-    def items(self) -> Iterable[Tuple[T, U]]:
+    def items(self) -> Iterable[Tuple[_T, _U]]:
         """
         Gets all items in store as list
         :return: List of (key, value)
         """
         return self._store.items()
 
-    def keys(self) -> Iterable[T]:
+    def keys(self) -> Iterable[_T]:
         """
         Gets all keys in store as list
         :return: List of keys
@@ -72,7 +72,7 @@ def __len__(self) -> int:
         """
         return len(self._store)
 
-    def pop(self, key: T) -> Optional[U]:
+    def pop(self, key: _T) -> Optional[_U]:
         """
         Pop an object from the store if it exists.
         :param key: key
@@ -81,31 +81,31 @@ def pop(self, key: T) -> Optional[U]:
             return self._store.pop(key)
         return None
 
-    def set(self, key: T, value: U) -> None:
+    def set(self, key: _T, value: _U) -> None:
         """
         Create or update a new value in store
         :param key: key
         :param value: value
         """
         self._store[key] = value
 
-    def values(self) -> Iterable[U]:
+    def values(self) -> Iterable[_U]:
         """
         Gets all values in store as list
         :return: List of values
         """
         return self._store.values()
 
 
-class ReadOnlyDataStore(Generic[T, U], Mapping):
+class ReadOnlyDataStore(Generic[_T, _U], Mapping):
     """
     A readonly view to a Data store
     """
 
-    def __init__(self, data: DataStore[T, U]):
-        self._data: DataStore[T, U] = data
+    def __init__(self, data: DataStore[_T, _U]):
+        self._data: DataStore[_T, _U] = data
 
-    def __getitem__(self, key: T) -> Optional[U]:
+    def __getitem__(self, key: _T) -> Optional[_U]:
         return self._data.get(key)
 
     def __len__(self) -> int:

src/electionguard/scheduler.py

@@ -5,11 +5,12 @@
 from multiprocessing.pool import Pool
 from psutil import cpu_count
 import traceback
-from typing import Any, Callable, Iterable, List
+from typing import Any, Callable, Iterable, List, TypeVar
 
 from .logs import log_warning
 from .singleton import Singleton
-from .utils import T
+
+_T = TypeVar("_T")
 
 
 class Scheduler(Singleton, AbstractContextManager):
@@ -58,7 +59,7 @@ def schedule(
         task: Callable,
         arguments: Iterable[Iterable[Any]],
         with_shared_resources: bool = False,
-    ) -> List[T]:
+    ) -> List[_T]:
         """
         Schedule tasks with list of arguments
         :param task: the callable task to execute
@@ -74,7 +75,7 @@ def schedule(
 
     def safe_starmap(
         self, pool: Pool, task: Callable, arguments: Iterable[Iterable[Any]]
-    ) -> List[T]:
+    ) -> List[_T]:
         """Safe wrapper around starmap to ensure pool is open"""
         try:
             return pool.starmap(task, arguments)
@@ -89,7 +90,9 @@ def safe_starmap(
             )
             return []
 
-    def safe_map(self, pool: Pool, task: Callable, arguments: Iterable[Any]) -> List[T]:
+    def safe_map(
+        self, pool: Pool, task: Callable, arguments: Iterable[Any]
+    ) -> List[_T]:
         """Safe wrapper around starmap to ensure pool is open"""
         try:
             return pool.map(task, arguments)

src/electionguard/serializable.py

@@ -19,7 +19,7 @@
 )
 
 S = TypeVar("S", bound="Serializable")
-T = TypeVar("T")
+_T = TypeVar("_T")
 
 JSON_FILE_EXTENSION: str = ".json"
 WRITE: str = "w"
@@ -165,29 +165,29 @@ def write_json_file(
         json_file.write(write_json(object_to_write, strip_privates))
 
 
-def read_json(data: Any, class_out: Type[T]) -> T:
+def read_json(data: Any, class_out: Type[_T]) -> _T:
     """
     Deserialize json file to object
     :param data: Json file data
     :param class_out: Object type
     :return: Deserialized object
     """
     set_deserializers()
-    return cast(T, loads(data, class_out))
+    return cast(_T, loads(data, class_out))
 
 
-def read_json_object(data: Any, class_out: Type[T]) -> T:
+def read_json_object(data: Any, class_out: Type[_T]) -> _T:
     """
     Deserialize json file to object
     :param data: Json file data
     :param class_out: Object type
     :return: Deserialized object
     """
     set_deserializers()
-    return cast(T, load(data, class_out))
+    return cast(_T, load(data, class_out))
 
 
-def read_json_file(class_out: Type[T], file_name: str, file_path: str = "") -> T:
+def read_json_file(class_out: Type[_T], file_name: str, file_path: str = "") -> _T:
     """
     Deserialize json file to object
     :param class_out: Object type
@@ -199,7 +199,7 @@ def read_json_file(class_out: Type[T], file_name: str, file_path: str = "") -> T
     json_file_path: str = path.join(file_path, file_name + JSON_FILE_EXTENSION)
     with open(json_file_path, READ) as json_file:
         data = json_file.read()
-        target: T = read_json(data, class_out)
+        target: _T = read_json(data, class_out)
     return target
 
 

src/electionguard/utils.py

@@ -3,11 +3,11 @@
 from re import sub
 from typing import Callable, Optional, TypeVar
 
-T = TypeVar("T")
-U = TypeVar("U")
+_T = TypeVar("_T")
+_U = TypeVar("_U")
 
 
-def get_optional(optional: Optional[T]) -> T:
+def get_optional(optional: Optional[_T]) -> _T:
     """
     General-purpose unwrapping function to handle `Optional`.
     Raises an exception if it's actually `None`, otherwise
@@ -18,8 +18,8 @@ def get_optional(optional: Optional[T]) -> T:
 
 
 def match_optional(
-    optional: Optional[T], none_func: Callable[[], U], some_func: Callable[[T], U]
-) -> U:
+    optional: Optional[_T], none_func: Callable[[], _U], some_func: Callable[[_T], _U]
+) -> _U:
     """
     General-purpose pattern-matching function to handle `Optional`.
     If it's actually `None`, the `none_func` lambda is called.
@@ -31,7 +31,7 @@ def match_optional(
         return some_func(optional)
 
 
-def get_or_else_optional(optional: Optional[T], alt_value: T) -> T:
+def get_or_else_optional(optional: Optional[_T], alt_value: _T) -> _T:
     """
     General-purpose getter for `Optional`. If it's `None`, returns the `alt_value`.
     Otherwise, returns the contents of `optional`.
@@ -42,7 +42,7 @@ def get_or_else_optional(optional: Optional[T], alt_value: T) -> T:
         return optional
 
 
-def get_or_else_optional_func(optional: Optional[T], func: Callable[[], T]) -> T:
+def get_or_else_optional_func(optional: Optional[_T], func: Callable[[], _T]) -> _T:
     """
     General-purpose getter for `Optional`. If it's `None`, calls the lambda `func`
     and returns its value. Otherwise, returns the contents of `optional`.
@@ -53,7 +53,9 @@ def get_or_else_optional_func(optional: Optional[T], func: Callable[[], T]) -> T
         return optional
 
 
-def flatmap_optional(optional: Optional[T], mapper: Callable[[T], U]) -> Optional[U]:
+def flatmap_optional(
+    optional: Optional[_T], mapper: Callable[[_T], _U]
+) -> Optional[_U]:
     """
     General-purpose flatmapping on `Optional`. If it's `None`, returns `None` as well,
     otherwise returns the lambda applied to the contents.