typing

spinn_utilities/logger_utils.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from spinn_utilities.log import FormatAdapter
+
 _already_issued = set()
 
 
-def warn_once(logger, msg):
+def warn_once(logger: FormatAdapter, msg: str) -> None:
     """
     Write a warning message to the given logger where that message should only
     be written to the logger once.
@@ -32,7 +34,7 @@ def warn_once(logger, msg):
     logger.warning(msg)
 
 
-def error_once(logger, msg):
+def error_once(logger: FormatAdapter, msg: str) -> None:
     """
     Write an error message to the given logger where that message should only
     be written to the logger once.
@@ -49,7 +51,7 @@ def error_once(logger, msg):
     logger.error(msg)
 
 
-def reset():
+def reset() -> None:
     """
     Clear the store of what messages have already been seen.
 

spinn_utilities/ordered_set.py

@@ -39,11 +39,11 @@ def __init__(self, iterable: Optional[Iterable[T]] = None):
         if iterable is not None:
             self.update(iterable)
 
-    def add(self, value: T):
+    def add(self, value: T) -> None:
         if value not in self._map:
             self._map[value] = None
 
-    def discard(self, value: T):
+    def discard(self, value: T) -> None:
         if value in self._map:
             self._map.pop(value)
 
@@ -72,7 +72,7 @@ def __len__(self) -> int:
     def __contains__(self, key: Any) -> bool:
         return key in self._map
 
-    def update(self, iterable: Iterable[T]):
+    def update(self, iterable: Iterable[T]) -> None:
         """
         Updates the set by adding each item in order
 

spinn_utilities/progress_bar.py

@@ -26,7 +26,6 @@
 from typing_extensions import Literal, Self
 
 from spinn_utilities.config_holder import get_config_bool
-from spinn_utilities.exceptions import SpiNNUtilsException
 from spinn_utilities.log import FormatAdapter
 from spinn_utilities.overrides import overrides
 from spinn_utilities import logger_utils

spinn_utilities/require_subclass.py

@@ -12,6 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Any, Callable, Dict, List, Type
+
+from spinn_utilities.abstract_base import AbstractBase
+
 
 class _RequiresSubclassTypeError(TypeError):
     """
@@ -22,7 +26,8 @@ class _RequiresSubclassTypeError(TypeError):
     """
 
 
-def require_subclass(required_class):
+def require_subclass(required_class: Type[AbstractBase]
+                     ) -> Callable[[Type[AbstractBase]], Type[AbstractBase]]:
     """
     Decorator that arranges for subclasses of the decorated class to
     require that they are also subclasses of the given class.
@@ -52,20 +57,22 @@ class AbstractVirtual(object):
     # without it, some very weird interactions with meta classes happen and I
     # really don't want to debug that stuff.
 
-    def decorate(target_class):
+    def decorate(target_class: Type[AbstractBase]) -> Type[AbstractBase]:
         # pylint: disable=unused-variable
         __class__ = target_class  # @ReservedAssignment # noqa: F841
 
-        def __init_subclass__(cls, allow_derivation=False, **kwargs):
+        def __init_subclass__(
+                cls: Type[AbstractBase], allow_derivation: bool = False,
+                **kwargs: Dict[str, Any]) -> None:
             if not issubclass(cls, required_class) and not allow_derivation:
                 raise _RequiresSubclassTypeError(
                     f"{cls.__name__} must be a subclass "
                     f"of {required_class.__name__} and the derivation was not "
                     "explicitly allowed with allow_derivation=True")
             try:
-                super().__init_subclass__(**kwargs)
+                super().__init_subclass__(**kwargs)  # type: ignore[misc]
             except _RequiresSubclassTypeError:
-                super().__init_subclass__(
+                super().__init_subclass__(    # type: ignore[misc]
                     allow_derivation=allow_derivation, **kwargs)
 
         setattr(target_class, '__init_subclass__',

spinn_utilities/safe_eval.py

@@ -12,6 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from types import CodeType, ModuleType
+from typing import Any, Dict, Union
+from typing_extensions import Buffer
+
 
 class SafeEval(object):
     """
@@ -42,7 +46,7 @@ class SafeEval(object):
     """
     __slots__ = ["_environment"]
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: ModuleType, **kwargs: Dict[str, Any]):
         """
         :param args:
             The symbols to use to populate the global reference table.
@@ -58,13 +62,15 @@ def __init__(self, *args, **kwargs):
             symbols (e.g., constants in numpy) do not have names that we can
             otherwise look up easily.
         """
-        env = {}
+        env: Dict[Any, Any] = {}
+        item: ModuleType
         for item in args:
             env[item.__name__] = item
         env.update(kwargs)
         self._environment = env
 
-    def eval(self, expression, **kwargs):
+    def eval(self, expression: Union[str, Buffer, CodeType],
+             **kwargs: Dict[str, Any]) -> Any:
         """
         Evaluate an expression and return the result.