[MRG] Caching and small run preparation improvements

.travis.yml

@@ -122,9 +122,9 @@ install:
        conda install --yes --quiet anaconda-client conda-build jinja2 pip setuptools;
     fi
   - if [[ $MINIMAL_VERSIONS == 'yes' ]]; then
-    travis_retry conda create -n travis_conda --yes --quiet pip python=$PYTHON numpy==1.9 scipy==0.14 libgfortran==1 nose sphinx ipython sympy==0.7.6 jinja2==2.7 pyparsing setuptools coverage;
+    travis_retry conda create -n travis_conda --yes --quiet pip python=$PYTHON numpy==1.9 scipy==0.14 libgfortran==1 nose "sphinx<1.6.3" ipython sympy==0.7.6 jinja2==2.7 pyparsing setuptools coverage;
     else
-    travis_retry conda create -n travis_conda --yes --quiet pip python=$PYTHON numpy nose sphinx ipython "sympy!=1.1.0" pyparsing jinja2 setuptools coverage;
+    travis_retry conda create -n travis_conda --yes --quiet pip python=$PYTHON numpy nose "sphinx<1.6.3" ipython "sympy!=1.1.0" pyparsing jinja2 setuptools coverage;
     fi
   - source activate travis_conda
   # On Python 2: Install an older version of scipy that still has weave

appveyor.yml

@@ -101,7 +101,7 @@ install:
   - 'python -c "import struct; print(struct.calcsize(''P'') * 8)"'
 
   # Install the build dependencies of the project via conda
-  - 'appveyor-retry conda install --yes --quiet numpy nose sphinx "sympy!=1.1.0" pyparsing jinja2 ipython setuptools cython'
+  - 'appveyor-retry conda install --yes --quiet numpy nose "sphinx<1.6.3" "sympy!=1.1.0" pyparsing jinja2 ipython setuptools cython'
   # Install an older version of scipy (which still has weave) on Python 2
   - 'if "%PYTHON_VERSION:~0,1%" == "2" appveyor-retry conda install --yes --quiet -c brian-team weave scipy'
   - 'if "%PYTHON_VERSION:~0,1%" == "3" appveyor-retry conda install --yes --quiet scipy'

brian2/core/variables.py

@@ -88,7 +88,6 @@ def variables_by_owner(variables, owner):
     return dict([(varname, var) for varname, var in variables.iteritems()
                  if getattr(var.owner, 'name', None) is owner_name])
 
-
 class Variable(object):
     '''
     An object providing information about model variables (including implicit
@@ -165,6 +164,16 @@ def __init__(self, name, dimensions=DIMENSIONLESS, owner=None, dtype=None,
         #: Whether the variable is an array
         self.array = array
 
+        #: Mark the list of attributes that should not be considered for caching
+        #: of state update code, etc.
+        self._cache_irrelevant_attributes = ['owner']
+
+    @property
+    def _state_tuple(self):
+        return tuple(value for key, value in self.__dict__.iteritems()
+                     if key not in (self._cache_irrelevant_attributes +
+                                    ['_cache_irrelevant_attributes']))
+
     @property
     def is_boolean(self):
         return np.issubdtype(np.bool, self.dtype)
@@ -274,9 +283,7 @@ def __repr__(self):
                                   constant=repr(self.constant),
                                   read_only=repr(self.read_only))
 
-    _state_tuple = property(lambda self: (self.dim, self.dtype, self.scalar,
-                                          self.constant, self.read_only,
-                                          self.dynamic, self.name))
+
 
 # ------------------------------------------------------------------------------
 # Concrete classes derived from `Variable` -- these are the only ones ever
@@ -341,11 +348,6 @@ def __init__(self, name, value, dimensions=DIMENSIONLESS, owner=None):
     def get_value(self):
         return self.value
 
-    # In contrast to other `Variable` objects, `Constant` objects are recreated
-    # for every run, so we cannot simply use their identity to compare them.
-    _state_tuple = property(lambda self: super(Constant, self)._state_tuple +
-                                         (self.value, ))
-
 
 class AuxiliaryVariable(Variable):
     '''
@@ -473,8 +475,6 @@ def get_addressable_value_with_unit(self, name, group):
         return VariableView(name=name, variable=self, group=group,
                             dimensions=self.dim)
 
-    _state_tuple = property(lambda self: super(ArrayVariable, self)._state_tuple +
-                                         (self.size, self.unique, id(self.device)))
 
 class DynamicArrayVariable(ArrayVariable):
     '''
@@ -559,6 +559,9 @@ def __init__(self, name, owner, size, device, dimensions=DIMENSIONLESS,
                                                    dynamic=True,
                                                    read_only=read_only,
                                                    unique=unique)
+        # The size of a dynamic variable can of course change and changes in
+        # size should not invalidate the cache
+        self._cache_irrelevant_attributes += ['size']
 
     @property
     def dimensions(self):
@@ -584,13 +587,6 @@ def resize(self, new_size):
 
         self.size = new_size
 
-    # Note that we inherit the state tuple from Variable, *not* from ArrayVariable.
-    # Otherwise the size would be part of the tuple, but of course the size of
-    # a dynamic variable can change.
-    _state_tuple = property(lambda self: super(ArrayVariable, self)._state_tuple +
-                                         (self.unique, id(self.device), self.ndim,
-                                          self.resize_along_first, self.needs_reference_update))
-
 
 class Subexpression(Variable):
     '''
@@ -670,9 +666,6 @@ def __repr__(self):
                                   expr=repr(self.expr),
                                   owner=self.owner.name)
 
-    _state_tuple = property(lambda self: super(Subexpression, self)._state_tuple +
-                                         (self.expr, id(self.device)))
-
 # ------------------------------------------------------------------------------
 # Classes providing views on variables and storing variables information
 # ------------------------------------------------------------------------------

brian2/equations/equations.py

@@ -426,6 +426,18 @@ def __init__(self, type, varname, dimensions, var_type=FLOAT, expr=None,
         # will be set later in the sort_subexpressions method of Equations
         self.update_order = -1
 
+        #: Mark the list of attributes that should not be considered for caching
+        #: of state update code, etc.
+        self._cache_irrelevant_attributes = ['update_order']
+
+    @property
+    def _state_tuple(self):
+        '''A tuple representing the full state of this object, used for
+        hashing and equality testing.'''
+        return tuple(value for key, value in self.__dict__.iteritems()
+                     if key not in (self._cache_irrelevant_attributes +
+                                    ['_cache_irrelevant_attributes']))
+
     unit = property(lambda self: get_unit(self.dim),
                     doc='The `Unit` of this equation.')
 
@@ -437,14 +449,6 @@ def __init__(self, type, varname, dimensions, var_type=FLOAT, expr=None,
                                                       if variable =='xi' or variable.startswith('xi_')]),
                                     doc='Stochastic variables in the RHS of this equation')
 
-
-    _state_tuple = property(lambda self: (self.type, self.varname,
-                                          self.dim, self.var_type,
-                                          self.expr, tuple(self.flags)),
-                            doc='A tuple representing the full state of this '
-                                'object, used for hashing and equality '
-                                'testing.')
-
     def __eq__(self, other):
         if not isinstance(other, SingleEquation):
             return NotImplemented

brian2/parsing/sympytools.py

@@ -165,40 +165,6 @@ def sympy_to_str(sympy_expr):
     return expr
 
 
-def replace_constants(sympy_expr, variables=None):
-    '''
-    Replace constant values in a sympy expression with their numerical value.
-
-    Parameters
-    ----------
-    sympy_expr : `sympy.Expr`
-        The expression
-    variables : dict-like, optional
-        Dictionary of `Variable` objects
-
-    Returns
-    -------
-    new_expr : `sympy.Expr`
-        Expressions with all constants replaced
-    '''
-    if variables is None:
-        return sympy_expr
-
-    symbols = set([symbol for symbol in sympy_expr.atoms()
-                   if isinstance(symbol, sympy.Symbol)])
-    for symbol in symbols:
-        symbol_str = str(symbol)
-        if symbol_str in variables:
-            var = variables[symbol_str]
-            if (getattr(var, 'scalar', False) and
-                    getattr(var, 'constant', False)):
-                # TODO: We should handle variables of other data types better
-                float_val = var.get_value()
-                sympy_expr = sympy_expr.xreplace({symbol: sympy.Float(float_val)})
-
-    return sympy_expr
-
-
 def expression_complexity(expr, complexity=None):
     '''
     Returns the complexity of an expression (either string or sympy)

brian2/tests/test_parsing.py

@@ -436,7 +436,8 @@ def test_sympytools():
                    'c * userfun(t + x)',  # non-sympy function
                    'abs(x) + ceil(y)',  # functions with a different name in sympy
                    'inf',  # constant with a different name in sympy
-                   ]
+                   'not(b)'  # boolean expression
+                  ]
 
     for expr in expressions:
         expr2 = sympy_to_str(str_to_sympy(expr))
@@ -447,7 +448,8 @@ def test_error_messages():
     nr = NodeRenderer()
     expr_expected = [('3^2', '^', '**'),
                      ('int(not_refractory | (v > 30))', '|', 'or'),
-                     ('int((v > 30) & (w < 20))', '&', 'and')]
+                     ('int((v > 30) & (w < 20))', '&', 'and'),
+                     ('x +* 3', '', '')]
     for expr, expected_1, expected_2 in expr_expected:
         try:
             nr.render_expr(expr)

brian2/utils/caching.py

@@ -82,7 +82,7 @@ def _hashable(obj):
 
     if isinstance(obj, set):
         return frozenset(_hashable(el) for el in obj)
-    elif isinstance(obj, list):
+    elif isinstance(obj, collections.Sequence):
         return tuple(_hashable(el) for el in obj)
     elif isinstance(obj, collections.Mapping):
         return frozenset((_hashable(key), _hashable(value))

rtd-requirements.txt

@@ -3,5 +3,5 @@ numpy>=1.4.1
 pyparsing==1.5.7
 sympy>=0.7.6
 sphinxcontrib-issuetracker
-sphinx>=1.5
+sphinx>=1.5,<1.6.3
 ipython