remove typing from docs

Author: Christian-B

spynnaker/pyNN/__init__.py

@@ -243,13 +243,13 @@ def distance(src_cell: IDMixin, tgt_cell: IDMixin,
 
     :param src_cell: Measure from this cell
     :param tgt_cell: To this cell
-    :param ~numpy.ndarray mask:
+    :param mask:
         allows only certain dimensions to be considered, e.g.:
 
         * to ignore the z-dimension, use ``mask=array([0,1])``
         * to ignore y, ``mask=array([0,2])``
         * to just consider z-distance, ``mask=array([2])``
-    :param float scale_factor:
+    :param scale_factor:
         allows for different units in the pre- and post-position
         (the post-synaptic position is multiplied by this quantity).
     :param float offset:
@@ -358,8 +358,6 @@ def setup(timestep: Optional[Union[float, Literal["auto"]]] = None,
 def name() -> str:
     """
     Returns the name of the simulator.
-
-    :rtype: str
     """
     return SpynnakerDataView.get_sim_name()
 
@@ -377,23 +375,16 @@ def Projection(
     Used to support PEP 8 spelling correctly.
 
     :param presynaptic_population: the source pop
-    :type presynaptic_population:
-        ~spynnaker.pyNN.models.populations.Population
     :param postsynaptic_population: the destination population
-    :type postsynaptic_population:
-        ~spynnaker.pyNN.models.populations.Population
-    :param AbstractConnector connector: the connector type
-    :param AbstractStaticSynapseDynamics synapse_type: the synapse type
-    :param None source: Unsupported; must be ``None``
-    :param str receptor_type: the receptor type
+    :param connector: the connector type
+    :param synapse_type: the synapse type
+    :param source: Unsupported; must be ``None``
+    :param receptor_type: the receptor type
     :param space: the space object
-    :type space: ~pyNN.space.Space or None
     :param label: the label
-    :type label: str or None
-    :param bool download_synapses: whether to download synapses
-    :param str partition_id: the partition id to use for the projection
+    :param download_synapses: whether to download synapses
+    :param partition_id: the partition id to use for the projection
     :return: a projection object for SpiNNaker
-    :rtype: ~spynnaker.pyNN.models.projection.Projection
     """
     return SpiNNakerProjection(
         pre_synaptic_population=presynaptic_population,
@@ -457,8 +448,6 @@ def list_standard_models() -> List[str]:
     """
     Return a list of all the StandardCellType classes available for this
     simulator.
-
-    :rtype: list(str)
     """
     return [
         key
@@ -482,9 +471,8 @@ def set_number_of_neurons_per_core(
     dimensions, it is recommended to set this to `None` here and then
     set the maximum on each Population.
 
-    :param type(PopulationVertex) neuron_type: neuron type
+    :param neuron_type: neuron type
     :param max_permitted: the number to set to
-    :type max_permitted: int or tuple or None
     """
     if isinstance(neuron_type, str):
         raise ConfigurationException(
@@ -546,13 +534,13 @@ def connect(pre: Population, post: Population, weight: float = 0.0,
     """
     Builds a projection.
 
-    :param ~spynnaker.pyNN.models.populations.Population pre: source pop
-    :param ~spynnaker.pyNN.models.populations.Population post: destination pop
-    :param float weight: weight of the connections
-    :param float delay: the delay of the connections
-    :param str receptor_type: excitatory / inhibitory
-    :param float p: probability
-    :param ~pyNN.random.NumpyRNG rng: random number generator
+    :param pre: source pop
+    :param post: destination pop
+    :param weight: weight of the connections
+    :param delay: the delay of the connections
+    :param receptor_type: excitatory / inhibitory
+    :param p: probability
+    :param rng: random number generator
     """
     SpynnakerDataView.check_user_can_act()
     __pynn["connect"](pre, post, weight, delay, receptor_type, p, rng)
@@ -566,10 +554,8 @@ def create(
     Builds a population with certain parameters.
 
     :param cellclass: population class
-    :type cellclass: type or AbstractPyNNModel
     :param cellparams: population parameters.
-    :param int n: number of neurons
-    :rtype: ~spynnaker.pyNN.models.populations.Population
+    :param n: number of neurons
     """
     SpynnakerDataView.check_user_can_act()
     return __pynn["create"](cellclass, cellparams, n)
@@ -580,7 +566,6 @@ def NativeRNG(seed_value: Union[int, List[int], NDArray]) -> None:
     Fixes the random number generator's seed.
 
     :param seed_value:
-    :type seed_value: int or list(int) or ~numpy.ndarray(int32)
     """
     __numpy.random.seed(seed_value)
 
@@ -601,7 +586,6 @@ def get_min_delay() -> int:
     least this.
 
     :return: returns the min delay of the simulation
-    :rtype: int
     """
     SpynnakerDataView.check_user_can_act()
     return __pynn["get_min_delay"]()
@@ -626,7 +610,6 @@ def get_time_step() -> float:
     The integration time step.
 
     :return: get the time step of the simulation (in ms)
-    :rtype: float
     """
     SpynnakerDataView.check_user_can_act()
     return float(__pynn["get_time_step"]())
@@ -637,8 +620,6 @@ def initialize(cells: PopulationBase, **initial_values: Any) -> None:
     Sets cells to be initialised to the given values.
 
     :param cells: the cells to change parameters on
-    :type cells: ~spynnaker.pyNN.models.populations.Population or
-        ~spynnaker.pyNN.models.populations.PopulationView
     :param initial_values: the parameters and their values to change
     """
     SpynnakerDataView.check_user_can_act()
@@ -653,7 +634,6 @@ def num_processes() -> int:
         Always 1 on SpiNNaker, which doesn't use MPI.
 
     :return: the number of MPI processes
-    :rtype: int
     """
     SpynnakerDataView.check_user_can_act()
     return __pynn["num_processes"]()
@@ -667,7 +647,6 @@ def rank() -> int:
         Always 0 on SpiNNaker, which doesn't use MPI.
 
     :return: MPI rank
-    :rtype: int
     """
     SpynnakerDataView.check_user_can_act()
     return __pynn["rank"]()
@@ -682,17 +661,12 @@ def record(variables: Union[str, Sequence[str]], source: PopulationBase,
     :param variables: may be either a single variable name or a list of
         variable names. For a given `celltype` class, `celltype.recordable`
         contains a list of variables that can be recorded for that `celltype`.
-    :type variables: str or list(str)
     :param source: where to record from
-    :type source: ~spynnaker.pyNN.models.populations.Population or
-        ~spynnaker.pyNN.models.populations.PopulationView
     :param str filename: file name to write data to
     :param sampling_interval:
         how often to sample the recording, not ignored so far
     :param annotations: the annotations to data writers
-    :type annotations: dict(str, ...)
     :return: neo object
-    :rtype: ~neo.core.Block
     """
     SpynnakerDataView.check_user_can_act()
     return __pynn["record"](variables, source, filename, sampling_interval,
@@ -704,7 +678,6 @@ def reset(annotations: Optional[Dict[str, Any]] = None) -> None:
     Resets the simulation to t = 0.
 
     :param annotations: the annotations to the data objects
-    :type annotations: dict(str, ...)
     """
     if annotations is None:
         annotations = {}
@@ -717,10 +690,9 @@ def run(simtime: float, callbacks: Optional[Callable] = None) -> float:
     The run() function advances the simulation for a given number of
     milliseconds.
 
-    :param float simtime: time to run for (in milliseconds)
+    :param simtime: time to run for (in milliseconds)
     :param callbacks: callbacks to run
     :return: the actual simulation time that the simulation stopped at
-    :rtype: float
     """
     SpynnakerDataView.check_user_can_act()
     return __pynn["run"](simtime, callbacks)
@@ -735,9 +707,8 @@ def run_until(tstop: float) -> float:
     """
     Run until a (simulation) time period has completed.
 
-    :param float tstop: the time to stop at (in milliseconds)
+    :param tstop: the time to stop at (in milliseconds)
     :return: the actual simulation time that the simulation stopped at
-    :rtype: float
     """
     SpynnakerDataView.check_user_can_act()
     return __pynn["run_until"](tstop, None)
@@ -748,7 +719,6 @@ def get_machine() -> Machine:
     Get the SpiNNaker machine in use.
 
     :return: the machine object
-    :rtype: ~spinn_machine.Machine
     """
     SpynnakerDataView.check_user_can_act()
     return SpynnakerDataView.get_machine()

spynnaker/pyNN/connections/ethernet_command_connection.py

@@ -36,16 +36,14 @@ def __init__(
             local_host: Optional[str] = None,
             local_port: Optional[int] = NOTIFY_PORT):
         """
-        :param AbstractEthernetTranslator translator:
+        :param translator:
             A translator of multicast commands to device commands
         :param command_containers:
             A list of vertices that have commands to be sent at the start
             and end of simulation
-        :type command_containers:
-            list(~spinn_front_end_common.abstract_models.AbstractSendMeMulticastCommandsVertex)
-        :param str local_host:
+        :param local_host:
             The optional host to listen on for the start/resume message
-        :param int local_port:
+        :param local_port:
             The optional port to listen on for the stop/pause message
         """
         super().__init__(
@@ -69,8 +67,6 @@ def add_command_container(
         :param command_container:
             A vertex that has commands to be sent at the start and end of
             simulation
-        :type command_container:
-            ~spinn_front_end_common.abstract_models.AbstractSendMeMulticastCommandsVertex
         """
         if not isinstance(
                 command_container, AbstractSendMeMulticastCommandsVertex):

spynnaker/pyNN/connections/ethernet_control_connection.py

@@ -30,13 +30,12 @@ def __init__(
             live_packet_gather_label: str, local_host: Optional[str] = None,
             local_port: Optional[int] = None):
         """
-        :param AbstractEthernetTranslator translator:
-            The translator of multicast to control commands
-        :param str label: The label of the vertex to attach the translator to
-        :param str live_packet_gather_label: The label of the LPG vertex that
+        :param translator: The translator of multicast to control commands
+        :param label: The label of the vertex to attach the translator to
+        :param live_packet_gather_label: The label of the LPG vertex that
             this control connection will listen to.
-        :param str local_host: The optional host to listen on
-        :param int local_port: The optional port to listen on
+        :param local_host: The optional host to listen on
+        :param local_port: The optional port to listen on
         """
         super().__init__(
             live_packet_gather_label, receive_labels=[label],
@@ -51,9 +50,8 @@ def add_translator(
         """
         Add another translator that routes via the LPG.
 
-        :param str label: The label of the vertex to attach the translator to
-        :param AbstractEthernetTranslator translator:
-            The translator of multicast to control commands
+        :param label: The label of the vertex to attach the translator to
+        :param translator: The translator of multicast to control commands
         """
         super().add_receive_label(label)
         self.__translators[label] = translator

spynnaker/pyNN/connections/spif_live_spikes_connection.py

@@ -85,22 +85,22 @@ def __init__(self, receive_labels: Optional[Iterable[str]],
                  local_host: Optional[str] = None,
                  local_port: Optional[int] = None):
         """
-        :param iterable(str) receive_labels:
+        :param receive_labels:
             Labels of vertices from which live events will be received.
-        :param str spif_host: The location of the SPIF board receiving packets
-        :param int spif_port: The port of the SPIF board (default 3332)
-        :param int events_per_packet:
+        :param spif_host: The location of the SPIF board receiving packets
+        :param spif_port: The port of the SPIF board (default 3332)
+        :param events_per_packet:
             The maximum number of events in each packet.  SPIF will be
             configured to send a packet as soon as it reaches this size if not
             before (default is 32)
-        :param int time_per_packet:
+        :param time_per_packet:
             The maximum time between sending non-empty packets.  SPIF will be
             configured to send a packet that isn't empty after this many
             microseconds (default is 500)
-        :param str local_host:
+        :param local_host:
             Optional specification of the local hostname or IP address of the
             interface to listen on
-        :param int local_port:
+        :param local_port:
             Optional specification of the local port to listen on. Must match
             the port that the toolchain will send the notification on (19999
             by default)
@@ -149,15 +149,14 @@ def add_init_callback(self, label: str, init_callback: _INIT) -> None:
         """
         Add a callback to be called to initialise a vertex.
 
-        :param str label:
+        :param abel:
             The label of the vertex to be notified about. Must be one of the
             vertices listed in the constructor
         :param init_callback: A function to be called to initialise the
             vertex. This should take as parameters the label of the vertex,
             the number of neurons in the population, the run time of the
             simulation in milliseconds, and the simulation timestep in
             milliseconds
-        :type init_callback: callable(str, int, float, float) -> None
         """
         self.__init_callbacks[label].append(init_callback)
 
@@ -167,13 +166,12 @@ def add_receive_callback(
         """
         Add a callback for the reception of live events from a vertex.
 
-        :param str label: The label of the vertex to be notified about.
+        :param label: The label of the vertex to be notified about.
             Must be one of the vertices listed in the constructor
         :param live_event_callback: A function to be called when events are
             received. This should take as parameters the label of the vertex,
             and an array-like of atom IDs.
-        :type live_event_callback: callable(str, list(int)) -> None
-        :param bool translate_key:
+        :param translate_key:
             True if the key is to be converted to an atom ID, False if the
             key should stay a key
         """
@@ -189,14 +187,11 @@ def add_start_resume_callback(
         """
         Add a callback for the start and resume state of the simulation.
 
-        :param str label: the label of the function to be sent
+        :param label: the label of the function to be sent
         :param start_resume_callback: A function to be called when the start
             or resume message has been received. This function should take
             the label of the referenced vertex, and an instance of this
             class, which can be used to send events.
-        :type start_resume_callback: callable(str,
-            ~spinn_front_end_common.utilities.connections.LiveEventConnection)
-            -> None
         """
         self.__start_resume_callbacks[label].append(start_resume_callback)
 
@@ -205,21 +200,15 @@ def add_pause_stop_callback(
         """
         Add a callback for the pause and stop state of the simulation.
 
-        :param str label: the label of the function to be sent
+        :param label: the label of the function to be sent
         :param pause_stop_callback: A function to be called when the pause
             or stop message has been received. This function should take the
             label of the referenced  vertex, and an instance of this class,
             which can be used to send events.
-        :type pause_stop_callback: callable(str,
-            ~spinn_front_end_common.utilities.connections.LiveEventConnection)
-            -> None
         """
         self.__pause_stop_callbacks[label].append(pause_stop_callback)
 
     def __read_database_callback(self, db_reader: DatabaseReader) -> None:
-        """
-        :param DatabaseReader db_reader:
-        """
         self.__handle_possible_rerun_state()
 
         vertex_sizes: Dict[str, int] = dict()