Merge pull request #1598 from SpiNNakerManchester/pylint4

Pylint4 fixes

Author: Christian-B

spynnaker/pyNN/connections/spif_live_spikes_connection.py

@@ -24,9 +24,9 @@
 from spinn_front_end_common.utilities.database import DatabaseConnection
 from spinn_front_end_common.utilities.database import DatabaseReader
 
-_EVENT: Final['TypeAlias'] = Callable[[str, List[int]], None]
-_INIT: Final['TypeAlias'] = Callable[[str, int, float, float], None]
-_START_STOP: Final['TypeAlias'] = Callable[
+Event: Final['TypeAlias'] = Callable[[str, List[int]], None]
+Init: Final['TypeAlias'] = Callable[[str, int, float, float], None]
+StartStop: Final['TypeAlias'] = Callable[
     [str, 'SPIFLiveSpikesConnection'], None]
 logger = FormatAdapter(logging.getLogger(__name__))
 
@@ -119,10 +119,10 @@ def __init__(self, receive_labels: Optional[Iterable[str]],
         self.__spif_packet_size = events_per_packet * BYTES_PER_WORD
         self.__spif_packet_time_us = time_per_packet
         self.__key_to_atom_id_and_label: Dict[int, Tuple[int, int]] = dict()
-        self.__live_event_callbacks: List[List[Tuple[_EVENT, bool]]] = list()
-        self.__start_resume_callbacks: Dict[str, List[_START_STOP]] = dict()
-        self.__pause_stop_callbacks: Dict[str, List[_START_STOP]] = dict()
-        self.__init_callbacks: Dict[str, List[_INIT]] = dict()
+        self.__live_event_callbacks: List[List[Tuple[Event, bool]]] = list()
+        self.__start_resume_callbacks: Dict[str, List[StartStop]] = dict()
+        self.__pause_stop_callbacks: Dict[str, List[StartStop]] = dict()
+        self.__init_callbacks: Dict[str, List[Init]] = dict()
         if receive_labels is not None:
             for label in receive_labels:
                 self.__live_event_callbacks.append(list())
@@ -147,7 +147,7 @@ def add_receive_label(self, label: str) -> None:
             self.__pause_stop_callbacks[label] = list()
             self.__init_callbacks[label] = list()
 
-    def add_init_callback(self, label: str, init_callback: _INIT) -> None:
+    def add_init_callback(self, label: str, init_callback: Init) -> None:
         """
         Add a callback to be called to initialise a vertex.
 
@@ -163,7 +163,7 @@ def add_init_callback(self, label: str, init_callback: _INIT) -> None:
         self.__init_callbacks[label].append(init_callback)
 
     def add_receive_callback(
-            self, label: str, live_event_callback: _EVENT,
+            self, label: str, live_event_callback: Event,
             translate_key: bool = True) -> None:
         """
         Add a callback for the reception of live events from a vertex.
@@ -185,7 +185,7 @@ def add_receive_callback(
             (live_event_callback, translate_key))
 
     def add_start_resume_callback(
-            self, label: str, start_resume_callback: _START_STOP) -> None:
+            self, label: str, start_resume_callback: StartStop) -> None:
         """
         Add a callback for the start and resume state of the simulation.
 
@@ -198,7 +198,7 @@ def add_start_resume_callback(
         self.__start_resume_callbacks[label].append(start_resume_callback)
 
     def add_pause_stop_callback(
-            self, label: str, pause_stop_callback: _START_STOP) -> None:
+            self, label: str, pause_stop_callback: StartStop) -> None:
         """
         Add a callback for the pause and stop state of the simulation.
 
@@ -259,7 +259,7 @@ def __handle_possible_rerun_state(self) -> None:
             self.__receiver_connection = None
 
     def __launch_thread(
-            self, kind: str, label: str, callback: _START_STOP) -> None:
+            self, kind: str, label: str, callback: StartStop) -> None:
         thread = Thread(target=callback, args=(label, self), name=(
             f"{kind} callback thread for live_event_connection "
             f"{self._local_port}:{self._local_ip_address}"))

spynnaker/pyNN/extra_algorithms/splitter_components/splitter_utils.py

@@ -21,13 +21,13 @@
 from spynnaker.pyNN.models.neuron.synapse_dynamics import (
     AbstractSynapseDynamics, SynapseDynamicsStatic)
 from spynnaker.pyNN.models.spike_source import SpikeSourcePoissonVertex
-from spynnaker.pyNN.types import DELAYS
+from spynnaker.pyNN.types import Delays
 
 
 def is_direct_poisson_source(
         post_vertex: ApplicationVertex, pre_vertex: ApplicationVertex,
         connector: AbstractConnector, dynamics: AbstractSynapseDynamics,
-        delay: DELAYS) -> bool:
+        delay: Delays) -> bool:
     """
     :param post_vertex: The receiving vertex
     :param pre_vertex: The vertex sending into the Projection

spynnaker/pyNN/models/neural_projections/connectors/abstract_connector.py

@@ -40,7 +40,7 @@
 
 from spynnaker.pyNN.data import SpynnakerDataView
 from spynnaker.pyNN.types import (
-    DELAYS, is_scalar, WEIGHTS_DELAYS, WEIGHTS)
+    Delays, is_scalar, WeightsDelays, Weights)
 from spynnaker.pyNN.utilities import utility_calls
 from spynnaker.pyNN.exceptions import SpynnakerException
 
@@ -122,7 +122,7 @@ def set_projection_information(
         self.__min_delay = SpynnakerDataView.get_simulation_time_step_ms()
 
     def _get_delay_minimum(
-            self, delays: DELAYS, n_connections: int,
+            self, delays: Delays, n_connections: int,
             synapse_info: SynapseInformation) -> float:
         """
         Get the minimum delay given a float or RandomDistribution.
@@ -147,7 +147,7 @@ def _get_delay_minimum(
         raise self.delay_type_exception(delays)
 
     def _get_delay_maximum(
-            self, delays: DELAYS, n_connections: int,
+            self, delays: Delays, n_connections: int,
             synapse_info: SynapseInformation) -> float:
         """
         Get the maximum delay given a float or RandomDistribution.
@@ -187,7 +187,7 @@ def get_delay_minimum(
         """
         raise NotImplementedError
 
-    def get_delay_variance(self, delays: DELAYS,
+    def get_delay_variance(self, delays: Delays,
                            synapse_info: SynapseInformation) -> float:
         """
         :param delays:
@@ -204,7 +204,7 @@ def get_delay_variance(self, delays: DELAYS,
         raise self.delay_type_exception(delays)
 
     def _get_n_connections_from_pre_vertex_with_delay_maximum(
-            self, delays: DELAYS, n_total_connections: int,
+            self, delays: Delays, n_total_connections: int,
             n_connections: int, min_delay: float, max_delay: float,
             synapse_info: SynapseInformation) -> int:
         """
@@ -278,7 +278,7 @@ def get_n_connections_to_post_vertex_maximum(
         """
         raise NotImplementedError
 
-    def get_weight_mean(self, weights: WEIGHTS,
+    def get_weight_mean(self, weights: Weights,
                         synapse_info: SynapseInformation) -> float:
         """
         :param weights:
@@ -295,7 +295,7 @@ def get_weight_mean(self, weights: WEIGHTS,
         raise self.weight_type_exception(synapse_info)
 
     def _get_weight_maximum(
-            self, weights: WEIGHTS, n_connections: int,
+            self, weights: Weights, n_connections: int,
             synapse_info: SynapseInformation) -> float:
         """
         Get the maximum of the weights.
@@ -331,7 +331,7 @@ def get_weight_maximum(self, synapse_info: SynapseInformation) -> float:
         """
         raise NotImplementedError
 
-    def get_weight_variance(self, weights: WEIGHTS,
+    def get_weight_variance(self, weights: Weights,
                             synapse_info: SynapseInformation) -> float:
         """
         :param weights:
@@ -393,7 +393,7 @@ def _generate_random_values(
         return copy_rd.next(n_connections)
 
     def _no_space_exception(
-            self, values: WEIGHTS_DELAYS,
+            self, values: WeightsDelays,
             synapse_info: SynapseInformation) -> SpynnakerException:
         """
         :param values:
@@ -407,7 +407,7 @@ def _no_space_exception(
             f"{synapse_info.post_population}")
 
     def weight_type_exception(
-            self, weights: WEIGHTS) -> SpynnakerException:
+            self, weights: Weights) -> SpynnakerException:
         """
         :param weights:
         :returns: An Exception explaining incorrect weight or delay type
@@ -430,7 +430,7 @@ def weight_type_exception(
         else:
             return SpynnakerException(f"Unrecognised weight {weights}")
 
-    def delay_type_exception(self, delays: DELAYS) -> SpynnakerException:
+    def delay_type_exception(self, delays: Delays) -> SpynnakerException:
         """
         :param delays:
         :returns: An Exception explaining incorrect delay type
@@ -450,7 +450,7 @@ def delay_type_exception(self, delays: DELAYS) -> SpynnakerException:
             return SpynnakerException(f"Unrecognised delay {delays}")
 
     def _generate_values(
-            self, values: WEIGHTS_DELAYS, sources: numpy.ndarray,
+            self, values: WeightsDelays, sources: numpy.ndarray,
             targets: numpy.ndarray, n_connections: int, post_slice: Slice,
             synapse_info: SynapseInformation,
             weights: bool) -> NDArray[float64]:

spynnaker/pyNN/models/neural_projections/connectors/abstract_generate_connector_on_machine.py

@@ -31,7 +31,7 @@
 from spynnaker.pyNN.models.common.param_generator_data import (
     param_generator_params, param_generator_params_size_in_bytes,
     param_generator_id, is_param_generatable)
-from spynnaker.pyNN.types import (DELAYS, WEIGHTS)
+from spynnaker.pyNN.types import (Delays, Weights)
 from spynnaker.pyNN.utilities.utility_calls import check_rng
 
 from .abstract_generate_connector_on_host import (
@@ -96,42 +96,42 @@ def generate_on_machine(self, synapse_info: SynapseInformation) -> bool:
             check_rng(synapse_info.delays.rng, "RandomDistribution in delay")
         return True
 
-    def gen_weights_id(self, weights: WEIGHTS) -> int:
+    def gen_weights_id(self, weights: Weights) -> int:
         """
         :param weights:
         :returns: The id of the weight generator on the machine.
         """
         return param_generator_id(weights)
 
-    def gen_weights_params(self, weights: WEIGHTS) -> NDArray[uint32]:
+    def gen_weights_params(self, weights: Weights) -> NDArray[uint32]:
         """
         :param weights:
         :returns: The parameters of the weight generator on the machine.
         """
         return param_generator_params(weights)
 
-    def gen_weight_params_size_in_bytes(self, weights:  WEIGHTS) -> int:
+    def gen_weight_params_size_in_bytes(self, weights: Weights) -> int:
         """
         :param weights:
         :returns: The size of the weight parameters in bytes.
         """
         return param_generator_params_size_in_bytes(weights)
 
-    def gen_delays_id(self, delays: DELAYS) -> int:
+    def gen_delays_id(self, delays: Delays) -> int:
         """
         :param delays:
         :returns: The id of the delay generator on the machine.
         """
         return param_generator_id(delays)
 
-    def gen_delay_params(self, delays: DELAYS) -> NDArray[uint32]:
+    def gen_delay_params(self, delays: Delays) -> NDArray[uint32]:
         """
         :param delays:
         :returns: The parameters of the delay generator on the machine.
         """
         return param_generator_params(delays)
 
-    def gen_delay_params_size_in_bytes(self, delays: DELAYS) -> int:
+    def gen_delay_params_size_in_bytes(self, delays: Delays) -> int:
         """
         :param delays:
         :returns: The size of the delay parameters in bytes.

spynnaker/pyNN/models/neural_projections/connectors/all_but_me_connector.py

@@ -24,7 +24,7 @@
 
 from spinn_front_end_common.utilities.constants import BYTES_PER_WORD
 from spinn_front_end_common.interface.ds import DataType
-from spynnaker.pyNN.types import WEIGHTS
+from spynnaker.pyNN.types import Weights
 
 from .abstract_connector import AbstractConnector
 from .abstract_generate_connector_on_machine import (
@@ -168,7 +168,7 @@ def get_weight_maximum(self, synapse_info: SynapseInformation) -> float:
             synapse_info)
 
     @overrides(AbstractConnector.get_weight_mean)
-    def get_weight_mean(self, weights: WEIGHTS,
+    def get_weight_mean(self, weights: Weights,
                         synapse_info: SynapseInformation) -> float:
         if self.__weights is None:
             return AbstractConnector.get_weight_mean(
@@ -177,7 +177,7 @@ def get_weight_mean(self, weights: WEIGHTS,
             return float(numpy.mean(numpy.abs(self.__weights)))
 
     @overrides(AbstractConnector.get_weight_variance)
-    def get_weight_variance(self, weights: WEIGHTS,
+    def get_weight_variance(self, weights: Weights,
                             synapse_info: SynapseInformation) -> float:
         if self.__weights is None:
             return AbstractConnector.get_weight_variance(

spynnaker/pyNN/models/neural_projections/connectors/from_list_connector.py

@@ -33,7 +33,7 @@
 
 from spynnaker.pyNN.data import SpynnakerDataView
 from spynnaker.pyNN.exceptions import InvalidParameterType
-from spynnaker.pyNN.types import DELAYS, WEIGHTS_DELAYS, WEIGHTS
+from spynnaker.pyNN.types import Delays, WeightsDelays, Weights
 from .abstract_connector import AbstractConnector
 from .abstract_generate_connector_on_host import (
     AbstractGenerateConnectorOnHost)
@@ -52,7 +52,7 @@
 _FIRST_PARAM = 2
 
 
-def _is_sequential(value: WEIGHTS_DELAYS
+def _is_sequential(value: WeightsDelays
                    ) -> TypeGuard[NDArray[numpy.float64]]:
     return isinstance(value, numpy.ndarray)
 
@@ -151,7 +151,7 @@ def get_delay_minimum(self, synapse_info: SynapseInformation) -> float:
             return numpy.min(self.__delays)
 
     @overrides(AbstractConnector.get_delay_variance)
-    def get_delay_variance(self, delays: DELAYS,
+    def get_delay_variance(self, delays: Delays,
                            synapse_info: SynapseInformation) -> float:
         if self.__delays is None:
             if _is_sequential(synapse_info.delays):
@@ -291,7 +291,7 @@ def get_n_connections_to_post_vertex_maximum(
             self.__targets.astype(int64, copy=False))))
 
     @overrides(AbstractConnector.get_weight_mean)
-    def get_weight_mean(self, weights: WEIGHTS,
+    def get_weight_mean(self, weights: Weights,
                         synapse_info: SynapseInformation) -> float:
         if self.__weights is None:
             if _is_sequential(synapse_info.weights):
@@ -312,7 +312,7 @@ def get_weight_maximum(self, synapse_info: SynapseInformation) -> float:
             return float(numpy.amax(numpy.abs(self.__weights)))
 
     @overrides(AbstractConnector.get_weight_variance)
-    def get_weight_variance(self, weights: WEIGHTS,
+    def get_weight_variance(self, weights: Weights,
                             synapse_info: SynapseInformation) -> float:
         if self.__weights is None:
             if _is_sequential(synapse_info.weights):

spynnaker/pyNN/models/neural_projections/connectors/kernel_connector.py

@@ -36,7 +36,7 @@
 
 from spynnaker.pyNN.exceptions import SpynnakerException
 from spynnaker.pyNN.types import (
-    DELAYS, WEIGHTS_DELAYS, WEIGHTS)
+    Delays, WeightsDelays, Weights)
 
 from .abstract_connector import AbstractConnector
 from .abstract_generate_connector_on_machine import (
@@ -251,7 +251,7 @@ def __pre_as_post(self, pre_r: int, pre_c: int) -> Tuple[int, int]:
         return (r, c)
 
     def __get_kernel_vals(self, values: Optional[Union[
-            _KERNAL, WEIGHTS_DELAYS]]) -> Optional[ConvolutionKernel]:
+            _KERNAL, WeightsDelays]]) -> Optional[ConvolutionKernel]:
         """
         Convert kernel values given into the correct format.
         """
@@ -278,8 +278,8 @@ def __get_kernel_vals(self, values: Optional[Union[
             f"{self._kernel_h} and width: {self._kernel_w}).")
 
     def __compute_statistics(
-            self, weights: Optional[WEIGHTS],
-            delays: Optional[DELAYS], post_vertex_slice: Slice,
+            self, weights: Optional[Weights],
+            delays: Optional[Delays], post_vertex_slice: Slice,
             n_pre_neurons: int) -> Tuple[
                 int, NDArray[uint32], NDArray[uint32], NDArray[floating],
                 NDArray[floating]]:
@@ -382,7 +382,7 @@ def get_delay_minimum(self, synapse_info: SynapseInformation) -> float:
             synapse_info.delays, n_conns, synapse_info)
 
     @overrides(AbstractConnector.get_delay_variance)
-    def get_delay_variance(self, delays: DELAYS,
+    def get_delay_variance(self, delays: Delays,
                            synapse_info: SynapseInformation) -> float:
         if self._krn_delays is not None:
             return float(numpy.var(self._krn_delays))
@@ -412,15 +412,15 @@ def get_weight_maximum(self, synapse_info: SynapseInformation) -> float:
             synapse_info.weights, n_conns, synapse_info)
 
     @overrides(AbstractConnector.get_weight_mean)
-    def get_weight_mean(self, weights: WEIGHTS,
+    def get_weight_mean(self, weights: Weights,
                         synapse_info: SynapseInformation) -> float:
         # Use the kernel weights if user has supplied them
         if self._krn_weights is not None:
             return float(numpy.mean(self._krn_weights))
         return super().get_weight_mean(weights, synapse_info)
 
     @overrides(AbstractConnector.get_weight_variance)
-    def get_weight_variance(self, weights: WEIGHTS,
+    def get_weight_variance(self, weights: Weights,
                             synapse_info: SynapseInformation) -> float:
         # Use the kernel weights if user has supplied them
         if self._krn_weights is not None: