Changeset 711

Timestamp:

02/16/10 10:59:22 (2 years ago)

Author:

apdavison

Message:

Moved Error classes out of common into an errors module (see ticket:157)

Location:

trunk

Files:

• setup.py (modified) (1 diff)
• src/__init__.py (modified) (1 diff)
• src/brian/cells.py (modified) (2 diffs)
• src/brian/simulator.py (modified) (4 diffs)
• src/common.py (modified) (17 diffs)
• src/connectors.py (modified) (2 diffs)
• src/errors.py (added)
• src/nest/__init__.py (modified) (5 diffs)
• src/nest/recording.py (modified) (4 diffs)
• src/nest/simulator.py (modified) (7 diffs)
• src/neuron/cells.py (modified) (2 diffs)
• src/neuron/simulator.py (modified) (4 diffs)
• src/pcsim/__init__.py (modified) (9 diffs)
• src/pcsim/cells.py (modified) (2 diffs)
• src/pcsim/simulator.py (modified) (6 diffs)
• test/unittests/generictests.py (modified) (14 diffs)

trunk/setup.py

@@ -41 +41 @@
 setup(
     name = "PyNN",
-    version = "0.6.0pre",
+    version = "0.7pre",
     package_dir={'pyNN': 'src'},
     packages = ['pyNN','pyNN.nest', 'pyNN.pcsim', 'pyNN.neuron', 'pyNN.brian', 'pyNN.recording'],

trunk/src/__init__.py

@@ -66 +66 @@
 """
 
-__version__ = '0.6.0pre ( $Rev$)'.replace(' $','')
-__all__ = ["common", "random", "nest", "neuron", "pcsim", "brian", "recording"]
+__version__ = '0.7pre ( $Rev$)'.replace(' $','')
+__all__ = ["common", "random", "nest", "neuron", "pcsim", "brian", "recording", "errors"]
 

trunk/src/brian/cells.py

@@ -5 +5 @@
 """
 
-from pyNN import common, cells
+from pyNN import common, cells, errors
 #import brian_no_units_no_warnings
 from brian.library.synapses import *
@@ -199 +199 @@
                 parameters['spike_times'] = numpy.array(parameters['spike_times'], float)
             except ValueError:
-                raise common.InvalidParameterValueError("spike times must be floats")
+                raise errors.InvalidParameterValueError("spike times must be floats")
         return super(SpikeSourceArray, cls).translate(parameters)
 

trunk/src/brian/simulator.py

@@ -32 +32 @@
 from itertools import izip
 import scipy.sparse
-from pyNN import common, cells
+from pyNN import common, cells, errors
 
 mV = brian.mV
@@ -267 +267 @@
             eqs = brian.Equations(cellclass)
         except Exception, errmsg:
-            raise common.InvalidModelError(errmsg)
+            raise errors.InvalidModelError(errmsg)
         v_thresh   = cellparams['v_thresh']
         v_reset    = cellparams['v_reset']
@@ -477 +477 @@
         assert len(targets) > 0
         if not isinstance(source, common.IDMixin):
-            raise common.ConnectionError("source should be an ID object, actually %s" % type(source))
+            raise errors.ConnectionError("source should be an ID object, actually %s" % type(source))
         for target in targets:
             if not isinstance(target, common.IDMixin):
-                raise common.ConnectionError("Invalid target ID: %s" % target)
+                raise errors.ConnectionError("Invalid target ID: %s" % target)
         assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets),len(weights),len(delays))
         if common.is_conductance(targets[0]):
@@ -492 +492 @@
             source_group = source.parent_group
         except AttributeError, errmsg:
-            raise common.ConnectionError("%s. Maybe trying to connect from non-existing cell (ID=%s)." % (errmsg, source))
+            raise errors.ConnectionError("%s. Maybe trying to connect from non-existing cell (ID=%s)." % (errmsg, source))
         target_group = targets[0].parent_group # we assume here all the targets belong to the same NeuronGroup
         bc = self._get_brian_connection(source_group,

trunk/src/common.py

@@ -7 +7 @@
 consistent with good performance (optimisations may require overriding some of
 the default definitions given here).
-
-Exceptions:
-    InvalidParameterValueError
-    NonExistentParameterError
-    InvalidDimensionsError
-    ConnectionError
-    InvalidModelError
-    RoundingWarning
-    NothingToWriteError
-    InvalidWeightError
-    NotLocalError
-    RecordingError    
 
 Utility functions and classes:
@@ -27 +15 @@
     check_delay()
     distance()
-    distances()
-    next_n()
-    ConstIter
     
 Accessing individual neurons:
@@ -61 +46 @@
     Population
     Projection
-    Connector
     
   4. Specification of synaptic plasticity:
@@ -78 +62 @@
 from math import *
 import operator
-from pyNN import random, utility, recording
+from pyNN import random, utility, recording, errors
 from string import Template
 
@@ -89 +73 @@
 logger = logging.getLogger("PyNN")
 
-class InvalidParameterValueError(ValueError):
-    """Inappropriate parameter value"""
-    pass
-
-class NonExistentParameterError(Exception):
-    """
-    Model parameter does not exist.
-    """
-    
-    def __init__(self, parameter_name, model):
-        self.parameter_name = parameter_name
-        if isinstance(model, type):
-            if issubclass(model, StandardModelType):
-                self.model_name = model.__name__
-                self.valid_parameter_names = model.default_parameters.keys()
-                self.valid_parameter_names.sort()
-        elif isinstance(model, basestring):
-            self.model_name = model
-            self.valid_parameter_names = ['unknown']
-        else:
-            raise Exception("When raising a NonExistentParameterError, model must be a class or a string, not a %s" % type(model))
-
-    def __str__(self):
-        return "%s (valid parameters for %s are: %s)" % (self.parameter_name,
-                                                         self.model_name,
-                                                         ", ".join(self.valid_parameter_names))
-
-class InvalidDimensionsError(Exception):
-    """Argument has inappropriate shape/dimensions."""
-    pass
-
-class ConnectionError(Exception):
-    """Attempt to create an invalid connection or access a non-existent connection."""
-    pass
-
-class InvalidModelError(Exception):
-    """Attempt to use a non-existent model type."""
-    pass
-
-class NoModelAvailableError(Exception):
-    """The simulator does not implement the requested model."""
-    pass
-
-class RoundingWarning(Warning):
-    """The argument has been rounded to a lower level of precision by the simulator."""
-    pass
-
-class NothingToWriteError(Exception):
-    """There is no data available to write."""
-    pass # subclass IOError?
-
-class InvalidWeightError(Exception): # subclass ValueError? or InvalidParameterValueError?
-    """Invalid value for the synaptic weight."""
-    pass
-
-class NotLocalError(Exception):
-    """Attempt to access a cell or connection that does not exist on this node (but exists elsewhere)."""
-    pass
-
-class RecordingError(Exception): # subclass AttributeError?
-    """Attempt to record a variable that does not exist for this cell type."""
-    
-    def __init__(self, variable, cell_type):
-        self.variable = variable
-        self.cell_type = cell_type
-        
-    def __str__(self):
-        return "Cannot record %s from cell type %s" % (self.variable, self.cell_type.__class__.__name__)
 
 
@@ -194 +110 @@
         all_positive = (filtered_weight>=0).all()
         if not (all_negative or all_positive):
-            raise InvalidWeightError("Weights must be either all positive or all negative")
+            raise errors.InvalidWeightError("Weights must be either all positive or all negative")
     elif is_number(weight):
         all_positive = weight >= 0
@@ -202 +118 @@
     if is_conductance or synapse_type == 'excitatory':
         if not all_positive:
-            raise InvalidWeightError("Weights must be positive for conductance-based and/or excitatory synapses")
+            raise errors.InvalidWeightError("Weights must be positive for conductance-based and/or excitatory synapses")
     elif is_conductance==False and synapse_type == 'inhibitory':
         if not all_negative:
-            raise InvalidWeightError("Weights must be negative for current-based, inhibitory synapses")
+            raise errors.InvalidWeightError("Weights must be negative for current-based, inhibitory synapses")
     else: # is_conductance is None. This happens if the cell does not exist on the current node.
         logger.debug("Can't check weight, conductance status unknown.")
@@ -215 +131 @@
     # If the delay is too small , we have to throw an error
     if delay < get_min_delay() or delay > get_max_delay():
-        raise ConnectionError("delay (%s) is out of range [%s,%s]" % (delay, get_min_delay(), get_max_delay()))
+        raise errors.ConnectionError("delay (%s) is out of range [%s,%s]" % (delay, get_min_delay(), get_max_delay()))
     return delay
 
@@ -323 +239 @@
                 val = self.get_parameters()[name]
             except KeyError:
-                raise NonExistentParameterError(name, self.cellclass)
+                raise errors.NonExistentParameterError(name, self.cellclass.__name__,
+                                                self.cellclass.default_parameters.keys())
         return val
     
@@ -492 +409 @@
                             parameters[k] = float(supplied_parameters[k]) 
                         except (ValueError, TypeError):
-                            raise InvalidParameterValueError(err_msg)
+                            raise errors.InvalidParameterValueError(err_msg)
                     # list and something that can be transformed to a list
                     elif type(default_parameters[k]) == types.ListType:
@@ -498 +415 @@
                             parameters[k] = list(supplied_parameters[k])
                         except TypeError:
-                            raise InvalidParameterValueError(err_msg)
+                            raise errors.InvalidParameterValueError(err_msg)
                     else:
-                        raise InvalidParameterValueError(err_msg)
+                        raise errors.InvalidParameterValueError(err_msg)
                 else:
-                    raise NonExistentParameterError(k, cls)
+                    raise errors.NonExistentParameterError(k, cls)
         return parameters
     
@@ -683 +600 @@
     for tgt in target:
         #if not isinstance(tgt, IDMixin):
-        #    raise ConnectionError("target is not a cell, actually %s" % type(tgt))
+        #    raise errors.ConnectionError("target is not a cell, actually %s" % type(tgt))
         sources = numpy.array(source, dtype=type(source))
         if p < 1:
@@ -794 +711 @@
             id = self.all_cells[addr]
         else:
-            raise InvalidDimensionsError, "Population has %d dimensions. Address was %s" % (self.ndim, str(addr))
+            raise errors.InvalidDimensionsError, "Population has %d dimensions. Address was %s" % (self.ndim, str(addr))
         return id
     
@@ -844 +761 @@
             coords = (idx,)
         else:
-            raise common.InvalidDimensionsError
+            raise errors.InvalidDimensionsError
         return coords
     
@@ -933 +850 @@
                 param_dict = {param: val}
             else:
-                raise InvalidParameterValueError
+                raise errors.InvalidParameterValueError
         elif isinstance(param, dict):
             param_dict = param
         else:
-            raise InvalidParameterValueError
+            raise errors.InvalidParameterValueError
         logger.debug("%s.set(%s)", self.label, param_dict)
         for cell in self:
@@ -953 +870 @@
             local_values = value_array[self._mask_local] # not sure this works
         else:
-            raise InvalidDimensionsError, "Population: %s, value_array: %s" % (str(self.dim),
+            raise errors.InvalidDimensionsError, "Population: %s, value_array: %s" % (str(self.dim),
                                                                                str(value_array.shape))
         assert local_values.shape[0] == self.local_cells.size, "%d != %d" % (local_values.size, self.local_cells.size)
@@ -1017 +934 @@
         """
         if not self.can_record(variable):
-            raise RecordingError(variable, self.celltype)
+            raise errors.RecordingError(variable, self.celltype)
         if isinstance(record_from, list): #record from the fixed list specified by user
             pass

trunk/src/connectors.py

@@ -20 +20 @@
                   fabs, floor, fmod, hypot, ldexp, log, log10, modf, pi, power, \
                   sin, sinh, sqrt, tan, tanh
-from pyNN import random, common
+from pyNN import random, common, errors
 
 logger = logging.getLogger("PyNN")
@@ -447 +447 @@
                 projection.connection_manager.connect(src, [tgt], float(w), float(d))
         else:
-            raise common.InvalidDimensionsError("OneToOneConnector does not support presynaptic and postsynaptic Populations of different sizes.")
+            raise errors.InvalidDimensionsError("OneToOneConnector does not support presynaptic and postsynaptic Populations of different sizes.")
 
 

trunk/src/nest/__init__.py

@@ -7 +7 @@
 import nest
 from pyNN.nest import simulator
-from pyNN import common, recording, __doc__
+from pyNN import common, recording, errors, __doc__
 common.simulator = simulator
 recording.simulator = simulator
@@ -217 +217 @@
                 param_dict = {param: float(val)}
             else:
-                raise common.InvalidParameterValueError
+                raise errors.InvalidParameterValueError
         elif isinstance(param,dict):
             param_dict = param
         else:
-            raise common.InvalidParameterValueError
+            raise errors.InvalidParameterValueError
         
         # The default implementation in common is is not very efficient for
@@ -237 +237 @@
                     self.celltype.default_parameters[key]
                 except Exception:
-                    raise common.NonExistentParameterError(key, self.celltype.__class__)
+                    raise errors.NonExistentParameterError(key, self.celltype.__class__)
                 if type(value) != type(self.celltype.default_parameters[key]):
                     if isinstance(value, int) and isinstance(self.celltype.default_parameters[key], float):
                         value = float(value)
                     else:
-                        raise common.InvalidParameterValueError("The parameter %s should be a %s, you supplied a %s" % (key,
+                        raise errors.InvalidParameterValueError("The parameter %s should be a %s, you supplied a %s" % (key,
                                                                                                                         type(self.celltype.default_parameters[key]),
                                                                                                                         type(value)))
@@ -264 +264 @@
                     nest.SetStatus(self.local_cells, key, value)
                 except Exception:
-                    raise common.InvalidParameterValueError
+                    raise errors.InvalidParameterValueError
 
     #def rset(self, parametername, rand_distr):
@@ -282 +282 @@
     #                self.celltype.default_parameters[parametername]
     #            except Exception:
-    #                raise common.NonExistentParameterError(parametername, self.celltype.__class__)
+    #                raise errors.NonExistentParameterError(parametername, self.celltype.__class__)
     #            if parametername == 'v_init':
     #                for cell,val in zip(self.local_cells, rarr):

trunk/src/nest/recording.py

@@ -4 +4 @@
 import logging
 import nest
-from pyNN import recording, common
+from pyNN import recording, common, errors
 from pyNN.nest import simulator
 
@@ -163 +163 @@
         else:
             if "filename" not in nest.GetStatus(self._device)[0]: # indicates that run() has not been called.
-                raise common.NothingToWriteError("No data. Have you called run()?")
+                raise errors.NothingToWriteError("No data. Have you called run()?")
             if simulator.state.num_threads > 1:
                 nest_files = []
@@ -191 +191 @@
         """Return the recorded data as a Numpy array."""
         if self._device is None:
-            raise common.NothingToWriteError("No cells recorded, so no data to return")
+            raise errors.NothingToWriteError("No cells recorded, so no data to return")
         
         if self.in_memory():
@@ -202 +202 @@
         """Write recorded data to file."""
         if self._device is None:
-            raise common.NothingToWriteError("%s not recorded from any cells, so no data to write to file." % self.variable)
+            raise errors.NothingToWriteError("%s not recorded from any cells, so no data to write to file." % self.variable)
         recording.Recorder.write(self, file, gather, compatible_output)
 

trunk/src/nest/simulator.py

@@ -27 +27 @@
 
 import nest
-from pyNN import common, random
+from pyNN import common, random, errors
 import logging
 import numpy
@@ -120 +120 @@
             exc_type, exc_value, traceback = sys.exc_info()
             if exc_type == 'NESTError' and "Unsupported Numpy array type" in exc_value:
-                raise common.InvalidParameterValueError()
+                raise errors.InvalidParameterValueError()
             else:
                 raise
@@ -159 +159 @@
         cell_gids = nest.Create(nest_model, n)
     except nest.NESTError, errmsg:
-        raise common.InvalidModelError(errmsg)
+        raise errors.InvalidModelError(errmsg)
     if cell_parameters:
         try:
@@ -317 +317 @@
         assert len(targets) > 0
         if self.synapse_type not in ('excitatory', 'inhibitory', None):
-            raise common.ConnectionError("synapse_type must be 'excitatory', 'inhibitory', or None (equivalent to 'excitatory')")
+            raise errors.ConnectionError("synapse_type must be 'excitatory', 'inhibitory', or None (equivalent to 'excitatory')")
         weights = weights*1000.0 # weights should be in nA or uS, but iaf_neuron uses pA and iaf_cond_neuron uses nS.
                                  # Using convention in this way is not ideal. We should
@@ -335 +335 @@
             nest.DivergentConnect([source], targets, weights, delays, self.synapse_model)            
         except nest.NESTError, e:
-            raise common.ConnectionError("%s. source=%s, targets=%s, weights=%s, delays=%s, synapse model='%s'" % (
+            raise errors.ConnectionError("%s. source=%s, targets=%s, weights=%s, delays=%s, synapse model='%s'" % (
                                          e, source, targets, weights, delays, self.synapse_model))
         self._connections = None # reset the caching of the connection list, since this will have to be recalculated
@@ -358 +358 @@
         assert len(sources) > 0, sources
         if self.synapse_type not in ('excitatory', 'inhibitory', None):
-            raise common.ConnectionError("synapse_type must be 'excitatory', 'inhibitory', or None (equivalent to 'excitatory')")
+            raise errors.ConnectionError("synapse_type must be 'excitatory', 'inhibitory', or None (equivalent to 'excitatory')")
         weights = weights*1000.0 # weights should be in nA or uS, but iaf_neuron uses pA and iaf_cond_neuron uses nS.
                                  # Using convention in this way is not ideal. We should
@@ -376 +376 @@
             nest.ConvergentConnect(sources, [target], weights, delays, self.synapse_model)            
         except nest.NESTError, e:
-            raise common.ConnectionError("%s. sources=%s, target=%s, weights=%s, delays=%s, synapse model='%s'" % (
+            raise errors.ConnectionError("%s. sources=%s, target=%s, weights=%s, delays=%s, synapse model='%s'" % (
                                          e, sources, target, weights, delays, self.synapse_model))
         self._connections = None # reset the caching of the connection list, since this will have to be recalculated

trunk/src/neuron/cells.py

@@ -6 +6 @@
 """
 
-from pyNN import common, cells
+from pyNN import common, cells, errors
 from neuron import h, nrn, hclass
 from math import pi
@@ -402 +402 @@
             self._spike_times = h.Vector(spike_times)
         except RuntimeError:
-            raise common.InvalidParameterValueError("spike_times must be an array of floats")
+            raise errors.InvalidParameterValueError("spike_times must be an array of floats")
         self.play(self._spike_times)
             

trunk/src/neuron/simulator.py

@@ -29 +29 @@
 
 from pyNN import __path__ as pyNN_path
-from pyNN import common, random
+from pyNN import common, random, errors
 import platform
 import logging
@@ -282 +282 @@
             cell_model = getattr(h, cellclass)
         except AttributeError:
-            raise common.InvalidModelError("There is no hoc template called %s" % cellclass)
+            raise errors.InvalidModelError("There is no hoc template called %s" % cellclass)
         cell_parameters = cellparams or {}
     elif isinstance(cellclass, type) and issubclass(cellclass, common.StandardCellType):
@@ -463 +463 @@
         if not isinstance(source, int) or source > state.gid_counter or source < 0:
             errmsg = "Invalid source ID: %s (gid_counter=%d)" % (source, state.gid_counter)
-            raise common.ConnectionError(errmsg)
+            raise errors.ConnectionError(errmsg)
         if not common.is_listlike(targets):
             targets = [targets]
@@ -473 +473 @@
         for target in targets:
             if not isinstance(target, common.IDMixin):
-                raise common.ConnectionError("Invalid target ID: %s" % target)
+                raise errors.ConnectionError("Invalid target ID: %s" % target)
               
         assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets),len(weights),len(delays))

trunk/src/pcsim/__init__.py

@@ -15 +15 @@
 
 import pyNN.random
-from pyNN import common, recording, __doc__
+from pyNN import common, recording, errors, __doc__
 from pyNN.pcsim import simulator
 common.simulator = simulator
@@ -223 +223 @@
 #    if delay  is None:  delay = simulator.state.min_delay
 #    if delay < get_min_delay():
-#        raise common.ConnectionError("Delay (%g ms) must be >= the minimum delay (%g ms)" % (delay, get_min_delay()))
+#        raise errors.ConnectionError("Delay (%g ms) must be >= the minimum delay (%g ms)" % (delay, get_min_delay()))
 #    # Convert units
 #    delay = delay / 1000 # Delays in pcsim are specified in seconds
@@ -236 +236 @@
 #            weight = 1e-9 * weight # Convert from nA to A
 #    except exceptions.Exception, e: # non-existent connection
-#        raise common.ConnectionError(e)
+#        raise errors.ConnectionError(e)
 #    # Create synapse factory
 #    syn_factory = 0
@@ -274 +274 @@
 #            return connections.idVector()
 #    except exceptions.TypeError, e:
-#        raise common.ConnectionError(e)
+#        raise errors.ConnectionError(e)
 #    except exceptions.Exception, e:
-#        raise common.ConnectionError(e)
+#        raise errors.ConnectionError(e)
 connect = common.connect
 set = common.set    
@@ -333 +333 @@
         if isinstance(cellclass, str):
             if not cellclass in dir(pypcsim):
-                raise common.InvalidModelError('Trying to create non-existent cellclass ' + cellclass )
+                raise errors.InvalidModelError('Trying to create non-existent cellclass ' + cellclass )
             cellclass = getattr(pypcsim, cellclass)
             self.celltype = cellclass
@@ -379 +379 @@
     ##        addr = (addr,)
     ##    if len(addr) != self.actual_ndim:
-    ##       raise common.InvalidDimensionsError, "Population has %d dimensions. Address was %s" % (self.actual_ndim, str(addr))
+    ##       raise errors.InvalidDimensionsError, "Population has %d dimensions. Address was %s" % (self.actual_ndim, str(addr))
     ##    orig_addr = addr;
     ##    while len(addr) < 3:
@@ -427 +427 @@
     ##        coords = (id,)
     ##    else:
-    ##        raise common.InvalidDimensionsError
+    ##        raise errors.InvalidDimensionsError
     ##    if self.actual_ndim == 1:
     ##        if coords[0] > self.dim[0]:
@@ -470 +470 @@
     ##            setattr(cell, parametername, val)
     ##    else:
-    ##        raise common.InvalidDimensionsError
+    ##        raise errors.InvalidDimensionsError
         
     ##def rset(self, parametername, rand_distr):
@@ -655 +655 @@
                 
             if len(possible_models) == 0:
-                raise common.NoModelAvailableError("The synapse model requested is not available.")
+                raise errors.NoModelAvailableError("The synapse model requested is not available.")
             synapse_type = getattr(pypcsim, list(possible_models)[0])
             try:

trunk/src/pcsim/cells.py

@@ -5 +5 @@
 """
 
-from pyNN import common, cells
+from pyNN import common, cells, errors
 import pypcsim
 import numpy
@@ -151 +151 @@
         spike_times = numpy.array(spike_times, float)
     except ValueError, e:
-        raise common.InvalidParameterValueError("Spike times must be floats. %s")
+        raise errors.InvalidParameterValueError("Spike times must be floats. %s")
     
     bins = (spike_times/time_step).astype('int')

trunk/src/pcsim/simulator.py

@@ -30 +30 @@
 import types
 import numpy
-from pyNN import common
+from pyNN import common, errors
 
 recorder_list = []
@@ -156 +156 @@
             cellfactory = cellclass(**cellparams)
         else:
-            raise common.InvalidModelError("Trying to create non-existent cellclass %s" % cellclass.__name__)
+            raise errors.InvalidModelError("Trying to create non-existent cellclass %s" % cellclass.__name__)
     else:
-        raise common.InvalidModelError("Trying to create non-existent cellclass %s" % cellclass)
+        raise errors.InvalidModelError("Trying to create non-existent cellclass %s" % cellclass)
 
     all_ids = numpy.array([i for i in net.add(cellfactory, n)], ID)
@@ -275 +275 @@
         if not isinstance(source, (int, long)) or source < 0:
             errmsg = "Invalid source ID: %s" % source
-            raise common.ConnectionError(errmsg)
+            raise errors.ConnectionError(errmsg)
         if not common.is_listlike(targets):
             targets = [targets]
@@ -285 +285 @@
         for target in targets:
             if not isinstance(target, common.IDMixin):
-                raise common.ConnectionError("Invalid target ID: %s" % target)
+                raise errors.ConnectionError("Invalid target ID: %s" % target)
         assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets),len(weights),len(delays))
         if common.is_conductance(targets[0]):
@@ -300 +300 @@
             syn_factory = synapse_type
         else:
-            raise common.ConnectionError("synapse_type must be a string or a PCSIM synapse factory. Actual type is %s" % type(synapse_type))
+            raise errors.ConnectionError("synapse_type must be a string or a PCSIM synapse factory. Actual type is %s" % type(synapse_type))
         for target, weight, delay in zip(targets, weights, delays):
             syn_factory.W = weight*weight_scale_factor
@@ -307 +307 @@
                 c = net.connect(source, target, syn_factory)
             except RuntimeError, e:
-                raise common.ConnectionError(e)
+                raise errors.ConnectionError(e)
             if target.local:
                 self.connections.append(Connection(source, target, net.object(c), 1.0/weight_scale_factor))

trunk/test/unittests/generictests.py

@@ -9 +9 @@
 import os
 import cPickle as pickle
-from pyNN import common, random, utility, recording
+from pyNN import common, random, utility, recording, errors
 import glob
 
@@ -66 +66 @@
         """create(): Trying to create a cell type which is not a standard cell or
         valid native cell should raise an Exception."""
-        self.assertRaises(common.InvalidModelError, sim.create, 'qwerty', n=10)
+        self.assertRaises(errors.InvalidModelError, sim.create, 'qwerty', n=10)
     
     def testCreateWithInvalidParameter(self):
         """create(): Creating a cell with an invalid parameter should raise an Exception."""
-        self.assertRaises(common.NonExistentParameterError, sim.create, sim.IF_curr_alpha, {'tau_foo':3.141592654})  
+        self.assertRaises(errors.NonExistentParameterError, sim.create, sim.IF_curr_alpha, {'tau_foo':3.141592654})  
 
 # ==============================================================================
@@ -136 +136 @@
         """connect(): Connecting from non-existent cell should raise a ConnectionError."""
         if self.postcells[0].local:
-            self.assertRaises(common.ConnectionError, sim.connect, 12345, self.postcells[0])
+            self.assertRaises(errors.ConnectionError, sim.connect, 12345, self.postcells[0])
         
     def testConnectNonExistentPostCell(self):
         """connect(): Connecting to a non-existent cell should raise a ConnectionError."""
-        self.assertRaises(common.ConnectionError, sim.connect, self.precells[0], 'cell45678')
+        self.assertRaises(errors.ConnectionError, sim.connect, self.precells[0], 'cell45678')
     
     def testInvalidSourceId(self):
         """connect(): sources must be integers."""
         self.precells.append('74367598')
-        self.assertRaises(common.ConnectionError, sim.connect, self.precells, self.postcells)
+        self.assertRaises(errors.ConnectionError, sim.connect, self.precells, self.postcells)
     
     def testInvalidTargetId(self):
         """connect(): targets must be integers."""
         self.postcells.append('99.9')
-        self.assertRaises(common.ConnectionError, sim.connect, self.precells, self.postcells)
+        self.assertRaises(errors.ConnectionError, sim.connect, self.precells, self.postcells)
     
     def testConnectTooSmallDelay(self):
-        self.assertRaises(common.ConnectionError, sim.connect, self.precells[0], self.postcells[0], delay=1e-12)
+        self.assertRaises(errors.ConnectionError, sim.connect, self.precells[0], self.postcells[0], delay=1e-12)
 
 # ==============================================================================
@@ -295 +295 @@
             try:
                 self.assertAlmostEqual(cell.tau_m, 35.7, 5)
-            except common.NotLocalError: # if cell is not on this node
+            except errors.NotLocalError: # if cell is not on this node
                 pass
         if self.single_cell.local:
@@ -306 +306 @@
                 self.assertAlmostEqual(cell.tau_syn_E, 5.432, 6)
                 self.assertAlmostEqual(cell.tau_m, 35.7, 5)
-            except common.NotLocalError: # if cell is not on this node
+            except errors.NotLocalError: # if cell is not on this node
                 pass
             
@@ -312 +312 @@
         # note that although syn_shape is added to the NEURON parameter dict when creating
         # an IF_curr_exp, it is not a valid parameter to be changed later.
-        self.assertRaises(common.NonExistentParameterError, sim.set, self.cells, 'syn_shape', 'alpha')
+        self.assertRaises(errors.NonExistentParameterError, sim.set, self.cells, 'syn_shape', 'alpha')
     
 # ==============================================================================
@@ -340 +340 @@
     
     def testInvalidCellType(self):
-        self.assertRaises(common.InvalidModelError, sim.Population, (3,3), 'qwerty', {})
+        self.assertRaises(errors.InvalidModelError, sim.Population, (3,3), 'qwerty', {})
         
 # ==============================================================================
@@ -377 +377 @@
         
     def testInvalidIndexDimension(self):
-        self.assertRaises(common.InvalidDimensionsError, self.net1.__getitem__, (10,2))
+        self.assertRaises(errors.InvalidDimensionsError, self.net1.__getitem__, (10,2))
         
 # ==============================================================================
@@ -475 +475 @@
                 
     def test_set_invalid_type(self):
-        self.assertRaises(common.InvalidParameterValueError, self.p1.set, 'foo', {})
-        self.assertRaises(common.InvalidParameterValueError, self.p1.set, [1,2,3])
+        self.assertRaises(errors.InvalidParameterValueError, self.p1.set, 'foo', {})
+        self.assertRaises(errors.InvalidParameterValueError, self.p1.set, [1,2,3])
                 
     def testSetInvalidFromDict(self):
-        self.assertRaises(common.InvalidParameterValueError, self.p1.set, {'v_thresh':'hello','tau_m':56.78})
+        self.assertRaises(errors.InvalidParameterValueError, self.p1.set, {'v_thresh':'hello','tau_m':56.78})
             
     def testSetNonexistentFromPair(self):
         """Population.set(): Trying to set a nonexistent parameter should raise an exception."""
-        self.assertRaises(common.NonExistentParameterError, self.p1.set, 'tau_foo', 10.0)
+        self.assertRaises(errors.NonExistentParameterError, self.p1.set, 'tau_foo', 10.0)
     
     def testSetNonexistentFromDict(self):
         """Population.set(): When some of the parameters in a dict are inexistent, an exception should be raised.
            There is no guarantee that the existing parameters will be set."""
-        self.assertRaises(common.NonExistentParameterError, self.p1.set, {'tau_foo': 10.0, 'tau_m': 21.0})
+        self.assertRaises(errors.NonExistentParameterError, self.p1.set, {'tau_foo': 10.0, 'tau_m': 21.0})
             
     def testRandomInit(self):
@@ -516 +516 @@
         """Population.tset(): If the size of the valueArray does not match that of the Population, should raise an InvalidDimensionsError."""
         array_in = numpy.array([[0.1,0.2,0.3],[0.4,0.5,0.6]])
-        self.assertRaises(common.InvalidDimensionsError, self.p1.tset, 'i_offset', array_in)
+        self.assertRaises(errors.InvalidDimensionsError, self.p1.tset, 'i_offset', array_in)
     
     def testTSetInvalidValues(self):
         """Population.tset(): If some of the values in the valueArray are invalid, should raise an exception."""
         array_in = numpy.array([['potatoes','carrots'],['oranges','bananas']])
-        self.assertRaises(common.InvalidParameterValueError, self.p2.tset, 'spike_times', array_in)
+        self.assertRaises(errors.InvalidParameterValueError, self.p2.tset, 'spike_times', array_in)
         
     def testRSetNumpy(self):
@@ -648 +648 @@
     def testSynapticConductanceRecording(self):
         # current-based synapses
-        self.assertRaises(common.RecordingError, self.pop2.record_gsyn)
+        self.assertRaises(errors.RecordingError, self.pop2.record_gsyn)
         # conductance-based synapses
         cells_to_record = [self.pop3[1,0], self.pop3[2,2]]
@@ -674 +674 @@
 
     def testRecordVmFromSpikeSource(self):
-        self.assertRaises(common.RecordingError, self.pop1.record_v)
+        self.assertRaises(errors.RecordingError, self.pop1.record_v)
         
     
@@ -896 +896 @@
             result = 2.345*numpy.ones(len(prj.connections))
             assert_arrays_almost_equal(numpy.array(weights), result, 1e-7, msg=prj.label)
-        self.assertRaises(common.InvalidWeightError, prj2.setWeights, 2.345) # current-based inhibitory needs negative weights
+        self.assertRaises(errors.InvalidWeightError, prj2.setWeights, 2.345) # current-based inhibitory needs negative weights
             
     def testSetNegativeWeights(self):
@@ -910 +910 @@
         assert_arrays_almost_equal(numpy.array(weights), result, 1e-7)
         for prj in prj1, prj3, prj4:
-            self.assertRaises(common.InvalidWeightError, prj.setWeights, -2.345) 
+            self.assertRaises(errors.InvalidWeightError, prj.setWeights, -2.345) 
     
     def test_set_weights_with_array(self):