Pragmatic solution to parameter changes in standalone mode

brian2/codegen/codeobject.py

@@ -1,13 +1,12 @@
 """
 Module providing the base `CodeObject` and related functions.
 """
-
 import collections
 import copy
 import platform
-import weakref
 
-from brian2.core.functions import Function
+from brian2.core.base import weakproxy_with_fallback
+from brian2.core.functions import DEFAULT_FUNCTIONS, Function
 from brian2.core.names import Nameable
 from brian2.equations.unitcheck import check_units_statements
 from brian2.utils.logger import get_logger
@@ -73,11 +72,7 @@ def __init__(
         name="codeobject*",
     ):
         Nameable.__init__(self, name=name)
-        try:
-            owner = weakref.proxy(owner)
-        except TypeError:
-            pass  # if owner was already a weakproxy then this will be the error raised
-        self.owner = owner
+        self.owner = weakproxy_with_fallback(owner)
         self.code = code
         self.compiled_code = {}
         self.variables = variables
@@ -86,6 +81,23 @@ def __init__(
         self.template_source = template_source
         self.compiler_kwds = compiler_kwds
 
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state["owner"] = self.owner.__repr__.__self__
+        # Replace Function objects for standard functions by their name
+        state["variables"] = self.variables.copy()
+        for k, v in state["variables"].items():
+            if isinstance(v, Function) and v is DEFAULT_FUNCTIONS[k]:
+                state["variables"][k] = k
+        return state
+
+    def __setstate__(self, state):
+        state["owner"] = weakproxy_with_fallback(state["owner"])
+        for k, v in state["variables"].items():
+            if isinstance(v, str):
+                state["variables"][k] = DEFAULT_FUNCTIONS[k]
+        self.__dict__ = state
+
     @classmethod
     def is_available(cls):
         """

brian2/core/variables.py

@@ -184,6 +184,15 @@ def __init__(
         #: Whether the variable is an array
         self.array = array
 
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state["owner"] = state["owner"].__repr__.__self__  # replace proxy
+        return state
+
+    def __setstate__(self, state):
+        state["owner"] = weakproxy_with_fallback(state["owner"])
+        self.__dict__ = state
+
     @property
     def is_boolean(self):
         return np.issubdtype(self.dtype, np.bool_)
@@ -1561,18 +1570,24 @@ def __repr__(self):
 
         return f"<{self.group_name}.{varname}: {values}>"
 
+    def __hash__(self):
+        return hash((self.group_name, self.name))
+
     # Get access to some basic properties of the underlying array
     @property
     def shape(self):
-        return self.get_item(slice(None), level=1).shape
+        if self.ndim == 1:
+            return (self.variable.size,)
+        else:
+            return self.variable.size
 
     @property
     def ndim(self):
-        return self.get_item(slice(None), level=1).ndim
+        return getattr(self.variable, "ndim", 1)
 
     @property
     def dtype(self):
-        return self.get_item(slice(None), level=1).dtype
+        return self.variable.dtype
 
 
 class Variables(Mapping):
@@ -1607,6 +1622,15 @@ def __init__(self, owner, default_index="_idx"):
         # Note that by using functools.partial (instead of e.g. a lambda
         # function) above, this object remains pickable.
 
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state["owner"] = state["owner"].__repr__.__self__
+        return state
+
+    def __setstate__(self, state):
+        state["owner"] = weakproxy_with_fallback(state["owner"])
+        self.__dict__ = state
+
     def __getitem__(self, item):
         return self._variables[item]