OSBModelValidation 0.2.18__py3-none-any.whl

omv/engines/pyneuron.py

@@ -0,0 +1,94 @@
+import subprocess as sp
+from textwrap import dedent
+from omv.engines.utils.wdir import working_dir
+from os.path import dirname
+import sys
+
+from omv.engines.neuron_ import NeuronEngine
+
+from omv.common.inout import inform, is_verbose, check_output
+from omv.engines.engine import EngineExecutionError
+
+
+class PyNRNEngine(NeuronEngine):
+    name = "PyNEURON"
+
+    @staticmethod
+    def is_installed():
+        ret = True
+        try:
+            inform(
+                "Checking whether %s is installed..." % PyNRNEngine.name,
+                indent=1,
+                verbosity=2,
+            )
+
+            ### Prints to stderr!!
+            # ret_str = check_output(['python -c "import neuron; print(neuron.h.nrnversion())"'], shell=True, verbosity=2)
+            import neuron
+
+            ret_str = neuron.h.nrnversion()
+
+            ret = "v%s" % ret_str.split()[3]
+            if is_verbose():
+                inform("PyNEURON version %s is correctly installed..." % ret, indent=2)
+
+        except Exception as err:
+            if is_verbose():
+                inform("Couldn't import NEURON into Python: ", err, indent=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        if not NeuronEngine.is_installed():
+            NeuronEngine.install(version)  # interpret version as version of NEURON!
+            inform("%s installed NEURON..." % PyNRNEngine.name, indent=2, verbosity=1)
+
+        environment_vars_nrn, path_nrn = NeuronEngine.get_nrn_environment()
+
+        PyNRNEngine.path = path_nrn
+        PyNRNEngine.environment_vars = {}
+        PyNRNEngine.environment_vars.update(environment_vars_nrn)
+
+        inform("PATH: " + PyNRNEngine.path, indent=2, verbosity=1)
+        inform("Env vars: %s" % PyNRNEngine.environment_vars, indent=2, verbosity=1)
+
+    def run(self):
+        try:
+            self.stdout = NeuronEngine.compile_modfiles(self.modelpath)
+        except sp.CalledProcessError as err:
+            self.stderr = err.output
+            self.returncode = err.returncode
+            inform("Error compiling modfiles:", self.stderr, indent=2)
+
+        with working_dir(dirname(self.modelpath)):
+            inform("Running %s on %s..." % (self.name, self.modelpath), indent=1)
+            p = sp.Popen(
+                ["nrniv", "-python", self.modelpath, "-nogui"],
+                stdin=sp.PIPE,
+                stdout=sp.PIPE,
+                stderr=sp.PIPE,
+            )
+            cmd = """\
+            %s
+            """ % (
+                "\n".join(self.extra_pars)
+            )
+            if sys.version_info[0] == 3:
+                c = dedent(cmd).encode()
+            else:
+                c = dedent(cmd)
+            stdout, stderr = p.communicate(c)
+            # with open('/tmp/omv_test.nrn.stdout', 'w') as f:
+            #     f.write(stdout)
+            self.stdout = str(stdout.decode())
+            self.stderr = str(stderr.decode())
+
+            inform("OUT: %s" % self.stdout, verbosity=1, indent=2)
+            inform("ERR: %s" % self.stderr, verbosity=1, indent=2)
+            inform("returncode: [%s]" % p.returncode, verbosity=1, indent=2)
+
+            self.returncode = p.returncode
+            if self.returncode != 0:
+                raise EngineExecutionError

omv/engines/pynn.py

@@ -0,0 +1,63 @@
+import os
+import subprocess as sp
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class PyNNEngine(OMVEngine):
+    name = "PyNN"
+
+    @staticmethod
+    def is_installed():
+        ret = True
+
+        inform(
+            "Checking whether %s is already installed..." % (PyNNEngine.name),
+            indent=1,
+            verbosity=1,
+        )
+        try:
+            # ret_str = sp.check_output(['python -c "import pyNN; print(pyNN.__version__)"'], shell=True,stderr=sp.STDOUT)
+            import pyNN
+
+            inform(
+                "pyNN version %s is correctly installed..." % pyNN.__version__,
+                indent=2,
+                verbosity=2,
+            )
+
+            ret = "v%s" % pyNN.__version__
+
+        except Exception as err:
+            inform("Couldn't import pyNN into Python: ", err, indent=1, verbosity=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version=None):
+        from omv.engines.getpynn import install_pynn
+
+        home = os.environ["HOME"]
+        inform("Will fetch and install pyNN (version info: %s)" % version, indent=2)
+        install_pynn(version)
+        inform("Done, PyNN is correctly installed...", indent=2)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["python", self.modelpath], cwd=os.path.dirname(self.modelpath)
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError
+        except Exception as err:
+            inform("Another error with running %s: " % self.name, err, indent=1)
+            self.returncode = -1
+            self.stdout = "???"

omv/engines/pynnbrian1.py

@@ -0,0 +1,59 @@
+import os
+import subprocess as sp
+
+from omv.engines.brian1 import Brian1Engine
+from omv.engines.pynn import PyNNEngine
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class PyNNBrian1Engine(PyNNEngine):
+    name = "PyNN_Brian1"
+    python3_compatible = Brian1Engine.python3_compatible
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % PyNNBrian1Engine.name, indent=1
+            )
+        return PyNNEngine.is_installed() and Brian1Engine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not Brian1Engine.is_installed():
+            Brian1Engine.install(version)  # interpret version as version of Brian!
+            inform(
+                "%s installed Brian..." % PyNNBrian1Engine.name, indent=2, verbosity=1
+            )
+        if not PyNNEngine.is_installed():
+            PyNNEngine.install(None)
+            inform(
+                "%s installed PyNN..." % PyNNBrian1Engine.name, indent=2, verbosity=1
+            )
+
+        PyNNBrian1Engine.path = PyNNEngine.path + ":" + Brian1Engine.path
+        PyNNBrian1Engine.environment_vars = {}
+        PyNNBrian1Engine.environment_vars.update(PyNNEngine.environment_vars)
+        PyNNBrian1Engine.environment_vars.update(Brian1Engine.environment_vars)
+        inform("PATH: " + PyNNBrian1Engine.path)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["python", self.modelpath, "brian"], cwd=os.path.dirname(self.modelpath)
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError
+        except Exception as err:
+            inform("Another error with running %s: " % self.name, err, indent=1)
+            self.returncode = -1
+            self.stdout = "???"

omv/engines/pynnbrian2.py

@@ -0,0 +1,60 @@
+import os
+import subprocess as sp
+
+from omv.engines.brian2_ import Brian2Engine
+from omv.engines.pynn import PyNNEngine
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class PyNNBrian2Engine(PyNNEngine):
+    name = "PyNN_Brian2"
+    python3_compatible = Brian2Engine.python3_compatible
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % PyNNBrian2Engine.name, indent=1
+            )
+        return PyNNEngine.is_installed() and Brian2Engine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not Brian2Engine.is_installed():
+            Brian2Engine.install(version)  # interpret version as version of Brian!
+            inform(
+                "%s installed Brian..." % PyNNBrian2Engine.name, indent=2, verbosity=1
+            )
+        if not PyNNEngine.is_installed():
+            PyNNEngine.install(None)
+            inform(
+                "%s installed PyNN..." % PyNNBrian2Engine.name, indent=2, verbosity=1
+            )
+
+        PyNNBrian2Engine.path = PyNNEngine.path + ":" + Brian2Engine.path
+        PyNNBrian2Engine.environment_vars = {}
+        PyNNBrian2Engine.environment_vars.update(PyNNEngine.environment_vars)
+        PyNNBrian2Engine.environment_vars.update(Brian2Engine.environment_vars)
+        inform("PATH: " + PyNNBrian2Engine.path)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["python", self.modelpath, "brian2"],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError
+        except Exception as err:
+            inform("Another error with running %s: " % self.name, err, indent=1)
+            self.returncode = -1
+            self.stdout = "???"

omv/engines/pynnnest.py

@@ -0,0 +1,56 @@
+import os
+import subprocess as sp
+
+from omv.engines.nestsli import NestEngine
+from omv.engines.pynest import PyNestEngine
+from omv.engines.pynn import PyNNEngine
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class PyNNNestEngine(PyNNEngine):
+    name = "PyNN_Nest"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % PyNNNestEngine.name, indent=1
+            )
+        return PyNNEngine.is_installed() and PyNestEngine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not PyNestEngine.is_installed():
+            PyNestEngine.install(version)  # interpret version as version of NEST!
+            inform(
+                "%s installed PyNest..." % PyNNNestEngine.name, indent=2, verbosity=1
+            )
+        if not PyNNEngine.is_installed():
+            PyNNEngine.install(None)
+            inform("%s installed PyNN..." % PyNNNestEngine.name, indent=2, verbosity=1)
+
+    def run(self):
+        try:
+            self.environment_vars = NestEngine.get_nest_environment()
+            self.set_environment()
+
+            inform("Env vars: %s" % self.environment_vars, indent=2)
+
+            inform(
+                "Running a file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["python", self.modelpath, "nest"], cwd=os.path.dirname(self.modelpath)
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError
+        except Exception as err:
+            inform("Another error with running %s: " % self.name, err, indent=1)
+            self.returncode = -1
+            self.stdout = "???"

omv/engines/pynnneuroml.py

@@ -0,0 +1,57 @@
+import os
+import subprocess as sp
+
+from omv.engines.pyneuroml_ import PyNeuroMLEngine
+from omv.engines.pynn import PyNNEngine
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class PyNNNeuroMLEngine(PyNNEngine):
+    name = "PyNN_NeuroML"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % PyNNNeuroMLEngine.name, indent=1
+            )
+        return PyNNEngine.is_installed() and PyNeuroMLEngine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not PyNeuroMLEngine.is_installed():
+            PyNeuroMLEngine.install(None)
+            inform(
+                "%s installed PyNeuroML..." % PyNNNeuroMLEngine.name,
+                indent=2,
+                verbosity=1,
+            )
+        if not PyNNEngine.is_installed():
+            PyNNEngine.install(None)
+            inform(
+                "%s installed PyNN..." % PyNNNeuroMLEngine.name, indent=2, verbosity=1
+            )
+
+    def run(self):
+        try:
+            inform("Env vars: %s" % self.environment_vars, indent=2)
+
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["python", self.modelpath, "neuroml"],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError
+        except Exception as err:
+            inform("Another error with running %s: " % self.name, err, indent=1)
+            self.returncode = -1
+            self.stdout = "???"

omv/engines/pynnneuron.py

@@ -0,0 +1,94 @@
+import os
+import subprocess as sp
+
+from omv.engines.neuron_ import NeuronEngine
+from omv.engines.pynn import PyNNEngine
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class PyNNNRNEngine(PyNNEngine):
+    name = "PyNN_NEURON"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed correctly..." % PyNNNRNEngine.name,
+                indent=1,
+            )
+        installed = PyNNEngine.is_installed() and NeuronEngine.is_installed()
+
+        return installed
+
+    @staticmethod
+    def install(version=None):
+        if not NeuronEngine.is_installed():
+            NeuronEngine.install(None)
+            inform("%s installed NEURON..." % PyNNNRNEngine.name, indent=2, verbosity=1)
+        if not PyNNEngine.is_installed():
+            PyNNEngine.install(None)
+            inform("%s installed PyNN..." % PyNNNRNEngine.name, indent=2, verbosity=1)
+
+        import pyNN
+
+        PyNNNRNEngine.path = PyNNEngine.path + ":" + NeuronEngine.path
+        PyNNNRNEngine.environment_vars = {}
+        PyNNNRNEngine.environment_vars.update(PyNNEngine.environment_vars)
+        PyNNNRNEngine.environment_vars.update(NeuronEngine.environment_vars)
+        inform("PATH: " + PyNNNRNEngine.path, indent=2, verbosity=1)
+        inform("Env vars: %s" % PyNNNRNEngine.environment_vars, indent=2, verbosity=1)
+
+        # pynn_loc = sp.check_output(['python -c "import pyNN,os; print(os.path.dirname(pyNN.__file__))"'], shell=True,stderr=sp.STDOUT).strip()
+        pynn_loc = pyNN.__file__[:-12]  # remove /__init__.py
+        pynn_mod_dir = "%s/neuron/nmodl/" % pynn_loc
+
+        inform(
+            "Attempting to compile PyNN mod files for standard models in %s..."
+            % pynn_mod_dir,
+            indent=2,
+            verbosity=1,
+        )
+
+        print(check_output(["ls", pynn_mod_dir], cwd=pynn_mod_dir))
+
+        environment_vars, path = NeuronEngine.get_nrn_environment()
+        inform(
+            "Using NEURON with env %s at %s..." % (environment_vars, path),
+            indent=2,
+            verbosity=1,
+        )
+
+        print(
+            check_output(
+                [environment_vars["NEURON_HOME"] + "/bin/nrnivmodl"], cwd=pynn_mod_dir
+            )
+        )
+
+    def run(self):
+        try:
+            self.stdout = NeuronEngine.compile_modfiles(self.modelpath)
+        except sp.CalledProcessError as err:
+            self.stderr = err.output
+            self.returncode = err.returncode
+            inform("Error compiling modfiles:", self.stderr, indent=2)
+
+        try:
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["python", self.modelpath, "neuron"],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError
+        except Exception as err:
+            inform("Another error with running %s: " % self.name, err, indent=1)
+            self.returncode = -1
+            self.stdout = "???"

omv/engines/utils/__init__.py

@@ -0,0 +1,21 @@
+from omv.engines.engine import PATH_DELIMITER
+
+def resolve_paths(path_s):
+    '''
+    Make explicit list from: '*.nml myfile.xml' etc.
+    '''
+
+    if "*" in path_s:
+        import glob
+
+        if PATH_DELIMITER in path_s:
+            all = []
+            for p in path_s.split(PATH_DELIMITER):
+                for g in glob.glob(p):
+                    all.append(g)
+            path_s = all
+        else:
+            path_s = glob.glob(path_s)
+
+    return path_s
+

omv/engines/utils/genesis_utils.g

@@ -0,0 +1,26 @@
+function total_membrane_area(cell)
+
+  float totalarea = 0
+  float totallength = 0
+  
+  str name
+  float area
+  float PI = 3.14159265359
+  
+  foreach name ({el {cell}/##[][TYPE=compartment],{cell}/##[][TYPE=symcompartment]})
+  
+    float length = {getfield {name} len}
+  
+    if (length == 0)
+        area = {PI}*{getfield {name} dia}*{getfield {name} dia}
+    else
+        area = {PI}*{getfield {name} dia}*{getfield {name} len}
+        totallength = totallength + length
+    end
+  
+    totalarea = totalarea + area
+    //echo "Compartment: " {name} ", area: " {area} ", length: " {length}", diam: " {getfield {name} dia}
+  
+  end
+  return {totalarea}
+end

omv/engines/utils/wdir.py

@@ -0,0 +1,15 @@
+import os
+
+
+class working_dir(object):
+    """Context manager for changing the current working directory"""
+
+    def __init__(self, newPath):
+        self.newPath = newPath
+
+    def __enter__(self):
+        self.savedPath = os.getcwd()
+        os.chdir(self.newPath)
+
+    def __exit__(self, etype, value, traceback):
+        os.chdir(self.savedPath)

omv/experiment.py

@@ -0,0 +1,18 @@
+from omv.analyzers import OMVAnalyzers
+
+
+class OMVExperiment(object):
+    def __init__(self, name, experiment, observables, engine, omt_root, mep_root):
+        self.name = name
+        self.checks = {}
+        self.results = None
+
+        for obsname, observable in observables.items():
+            # an experiment can have multiple observables
+            expected = experiment["expected"].get(obsname)
+            self.checks[obsname] = OMVAnalyzers[obsname](
+                observable, expected, engine, omt_root, mep_root
+            )
+
+    def check_all(self):
+        return {n: c() for n, c in self.checks.items()}