OSBModelValidation 0.2.18__py3-none-any.whl

omv/engines/neuron_.py

@@ -0,0 +1,205 @@
+import os
+import sys
+from glob import glob
+import platform
+import subprocess as sp
+from textwrap import dedent
+from omv.engines.utils.wdir import working_dir
+from omv.engines.engine import OMVEngine, EngineExecutionError
+from os.path import dirname
+from omv.common.inout import check_output, inform, is_verbose
+from sysconfig import get_paths
+
+
+class NeuronEngine(OMVEngine):
+    name = "NEURON"
+
+    def __init__(self, target, do_not_check_install=False, engine_version=None):
+        super(NeuronEngine, self).__init__(target, do_not_check_install, engine_version)
+
+        inform(
+            "Checking whether %s (v %s) is already installed..."
+            % (self.name, engine_version),
+            indent=1,
+            verbosity=1,
+        )
+        if not self.is_installed():
+            try:
+                self.install(engine_version)
+            except Exception as e:
+                inform(e)
+                raise (EngineInstallationError(e))
+
+        self.environment_vars, self.path = NeuronEngine.get_nrn_environment()
+        self.set_environment()
+        self.set_path()
+
+    @staticmethod
+    def get_nrn_environment():
+        home = os.environ["HOME"]
+        arch = platform.machine()
+        pp = os.path.join(home, "local/lib/python/site-packages")
+
+        environment_vars = {"PYTHONPATH": pp}
+
+        if not "NEURON_HOME" in os.environ:
+            pip_install_dir1 = "/usr/local"
+            pip_install_nrniv1 = os.path.join(pip_install_dir1, "bin", "nrniv")
+            scripts_bin = get_paths()["scripts"]
+            pip_install_dir2 = scripts_bin[: scripts_bin.rfind("/")]
+            pip_install_nrniv2 = os.path.join(pip_install_dir2, "bin", "nrniv")
+
+            inform(
+                "Checking NEURON at: %s or %s (%s)"
+                % (pip_install_nrniv1, pip_install_nrniv2, get_paths()),
+                indent=1,
+                verbosity=1,
+            )
+            if os.path.isfile(pip_install_nrniv1):
+                environment_vars["NEURON_HOME"] = pip_install_dir1
+                path = os.path.join(pip_install_dir1, "bin")
+            elif os.path.isfile(pip_install_nrniv2):
+                environment_vars["NEURON_HOME"] = pip_install_dir2
+                path = os.path.join(pip_install_dir2, "bin")
+            else:
+                environment_vars["NEURON_HOME"] = os.path.join(
+                    home, "neuron/nrn/", arch
+                )
+                path = os.path.join(home, "neuron/nrn/", arch, "bin")
+        else:
+            environment_vars["NEURON_HOME"] = os.environ["NEURON_HOME"]
+            path = os.path.join(os.environ["NEURON_HOME"], "bin")
+
+        inform(
+            "NEURON environment vars: %s, PATH: %s" % (environment_vars, path),
+            indent=1,
+            verbosity=1,
+        )
+
+        return environment_vars, path
+
+    @staticmethod
+    def is_installed():
+        ret = True
+        if is_verbose():
+            inform("Checking whether %s is installed..." % NeuronEngine.name, indent=1)
+        try:
+            output = check_output(["nrniv", "--version"], verbosity=2)
+            if is_verbose():
+                inform(
+                    "%s is installed; env: %s"
+                    % (output.strip(), NeuronEngine.get_nrn_environment()),
+                    indent=2,
+                )
+            ret = "v%s" % output.split()[3]
+        except OSError:
+            try:
+                environment_vars, path = NeuronEngine.get_nrn_environment()
+                if is_verbose():
+                    inform(
+                        "Testing NEURON with env: %s and path: %s"
+                        % (environment_vars, path),
+                        indent=2,
+                    )
+                output = check_output([path + "/nrniv", "--version"], verbosity=3)
+                if is_verbose():
+                    inform(
+                        "%s was already installed (by OMV..?)" % output.strip(),
+                        indent=2,
+                    )
+
+                ret = "v%s" % output.split()[3]
+            except OSError:
+                if is_verbose():
+                    inform("NEURON not currently installed", indent=2)
+                ret = False
+        return ret
+
+    @classmethod
+    def install(cls, version):
+        from omv.engines.getnrn import install_neuron
+
+        inform("Will fetch and install the latest NEURON version", indent=2)
+        install_neuron(version)
+
+        cls.environment_vars, cls.path = NeuronEngine.get_nrn_environment()
+
+    @classmethod
+    def compile_modfiles(cls, modelpath):
+        with working_dir(dirname(modelpath)):
+            out = 0
+            if len(glob("*.mod")) > 0:
+                environment_vars, path = NeuronEngine.get_nrn_environment()
+                inform(
+                    "Compiling all mod files in directory: %s" % dirname(modelpath),
+                    indent=1,
+                )
+                out = check_output([path + "/nrnivmodl"])
+                inform(out, indent=2)
+            elif len(glob("modfiles/*.mod")) > 0:
+                environment_vars, path = NeuronEngine.get_nrn_environment()
+                mod_file_path = dirname(modelpath) + "/modfiles"
+                inform(
+                    "Compiling all mod files in directory: %s" % mod_file_path, indent=1
+                )
+                out = check_output([path + "/nrnivmodl", "modfiles"])
+                inform(out, indent=2)
+            elif len(glob("mod_files/*.mod")) > 0:
+                environment_vars, path = NeuronEngine.get_nrn_environment()
+                mod_file_path = dirname(modelpath) + "/mod_files"
+                inform(
+                    "Compiling all mod files in directory: %s" % mod_file_path, indent=1
+                )
+                out = check_output([path + "/nrnivmodl", "mod_files"])
+                inform(out, indent=2)
+        return out
+
+    def run(self):
+        try:
+            self.stdout = self.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"], stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE)
+            cmd = """\
+            load_file("noload.hoc")
+            //cvode_active(1)
+            load_file("%s")
+            %s
+            """ % (
+                self.modelpath,
+                "\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
+
+    def build_query_string(self, name, cmd):
+        return '{{%s}{print "%s: ", %s}}' % (cmd, name, name)
+
+    def query_area(self, secname):
+        qname = "area_%s" % secname
+        qcmd = 'forsec "%s" {for (x,0) area_%s+=area(x)}' % (secname, secname)
+        name = self.register_query(qname, qcmd)
+        return name
+
+    def query_temperature(self):
+        return self.register_query("temperature", "temperature=celsius")

omv/engines/octave.py

@@ -0,0 +1,51 @@
+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 OctaveEngine(OMVEngine):
+    name = "Octave"
+
+    @staticmethod
+    def is_installed():
+        ret = True
+
+        try:
+            ret_str = check_output(["octave", "-v"], verbosity=1)
+
+            ret = "v%s" % str(ret_str).split()[3]
+        except OSError as err:
+            if is_verbose():
+                inform("Couldn't execute Octave!", err, indent=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.getoctave import install_octave
+
+        inform("Will fetch and install the latest Octave", indent=2)
+        install_octave()
+        inform("Done...", indent=2)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["octave", "--no-window-system", "--silent", 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/pylems.py

@@ -0,0 +1,57 @@
+import os
+import subprocess as sp
+import sys
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class PyLemsEngine(OMVEngine):
+    name = "PyLEMS"
+
+    @staticmethod
+    def is_installed():
+        ret = True
+        try:
+            import lems
+
+            ret = "v%s" % lems.__version__
+            inform("PyLEMS %s is correctly installed..." % ret, indent=2, verbosity=2)
+
+        except Exception as err:
+            if is_verbose():
+                inform("Couldn't execute/import PyLEMS: ", err, indent=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.getpylems import install_pylems
+
+        home = os.environ["HOME"]
+        p = os.path.join(home, "pylems")
+        PyLemsEngine.path = p
+        PyLemsEngine.environment_vars = {"PYLEMS_HOME": p}
+        inform("Will fetch and install the latest PyLEMS", indent=2)
+        install_pylems()
+        inform("Done...", indent=2)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["pylems", self.modelpath, "-nogui"],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Process error with %s: " % self.name, err, indent=1)
+            self.returncode = err.returncode
+            raise EngineExecutionError
+        except Exception as err:
+            inform("Another error with running %s: " % self.name, err, indent=1)
+            self.returncode = -1
+            self.stdout = "???"

omv/engines/pylemsnml2.py

@@ -0,0 +1,59 @@
+import os
+import subprocess as sp
+
+from omv.engines.pylems import PyLemsEngine
+from omv.engines.getnml2 import default_nml2_dir, install_nml2
+
+from omv.common.inout import inform, trim_path, is_verbose
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class PyLemsNeuroML2Engine(OMVEngine):
+    name = "PyLEMS_NeuroML2"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % PyLemsNeuroML2Engine.name,
+                indent=1,
+            )
+
+        nml2_installed = os.path.isdir(default_nml2_dir)
+
+        if nml2_installed and PyLemsEngine.is_installed():
+            return PyLemsEngine.is_installed()
+        else:
+            return False
+
+    def install(self, version):
+        if not PyLemsEngine.is_installed():
+            PyLemsEngine.install(None)
+        if not os.path.isdir(default_nml2_dir):
+            install_nml2()
+
+        inform("Finished installation of %s..." % self.name, indent=2)
+
+    def run(self):
+        try:
+            nml2_comp_type_def_dir = os.path.join(default_nml2_dir, "NeuroML2CoreTypes")
+
+            inform(
+                "Running file %s with %s, including path: %s"
+                % (trim_path(self.modelpath), self.name, nml2_comp_type_def_dir),
+                indent=1,
+            )
+
+            self.stdout = sp.check_output(
+                ["pylems", "-I", nml2_comp_type_def_dir, self.modelpath, "-nogui"],
+                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/pynest.py

@@ -0,0 +1,111 @@
+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
+
+from omv.engines.nestsli import NestEngine
+import sys
+
+
+class PyNestEngine(OMVEngine):
+    name = "PyNEST"
+
+    @staticmethod
+    def is_installed():
+        PyNestEngine.environment_vars = NestEngine.get_nest_environment()
+        sys.path.append(PyNestEngine.environment_vars["PYTHONPATH"])
+
+        ret = True
+        try:
+            # print('PN1')
+            try:
+                # print('PN1a')
+                ret_str_cmd_line = check_output(
+                    [
+                        "python -c \"import nest; print(nest.__version__ if hasattr(nest,'__version__') else nest.version())\""
+                    ],
+                    shell=True,
+                    verbosity=2,
+                )
+
+                # if is_verbose():
+                #    inform("NEST cmd line test: <<<%s>>>" % (ret_str_cmd_line), indent=2)
+                ret_str = (
+                    ret_str_cmd_line.split("Version: ")[1].split("Built:")[0].strip()
+                )
+                # print("ret_str: %s"%ret_str)
+            except Exception as e:
+                if is_verbose():
+                    print("NEST installed check exception: %s" % e)
+                import nest
+
+                # print('PN2')
+                if hasattr(nest, "__version__"):
+                    # print('PN3')
+                    ret_str = nest.__version__
+                else:
+                    # print('PN4')
+                    ret_str = nest.version()
+
+            ret = len(ret_str) > 0
+
+            if ret:
+                ret_str = ret_str.strip().split("\n")[-1]
+                # print('NEST info: %s; <<%s>>'%(ret, ret_str))
+                if "Version" in ret_str:
+                    ret = "v%s" % ret_str.split("Version")[-1].split()[0]
+                elif "-" in ret_str:
+                    ret = "v%s" % ret_str.split("-")[-1].split()[0]
+                else:
+                    ret = "v%s" % ret_str.split()[-1]
+
+            if ret and is_verbose():
+                inform("%s is correctly installed..." % (PyNestEngine.name), indent=2)
+
+            if is_verbose():
+                inform("NEST is installed with Python support...", indent=2)
+                inform("Env vars: %s" % PyNestEngine.environment_vars, indent=2)
+
+        except Exception as err:
+            if is_verbose():
+                inform("Couldn't import (py)NEST into Python..: ", err, indent=1)
+                inform("NEST env vars: %s" % PyNestEngine.environment_vars, indent=1)
+                inform("sys.path: %s" % sys.path, indent=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        NestEngine.install(version)
+        PyNestEngine.path = NestEngine.path
+        PyNestEngine.environment_vars = NestEngine.environment_vars
+        inform("Finished installation of PyNEST....", indent=2)
+
+    def run(self):
+        self.environment_vars = NestEngine.get_nest_environment()
+        self.set_environment()
+
+        sys.path.append(self.environment_vars["PYTHONPATH"])
+
+        inform("Env vars: %s" % self.environment_vars, indent=2)
+        inform("sys.path: %s" % sys.path, indent=1)
+
+        try:
+            inform(
+                "Running the file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["python", self.modelpath, "-nogui"],
+                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/pyneuroconstruct.py

@@ -0,0 +1,67 @@
+import os
+
+from omv.engines.utils.wdir import working_dir
+
+from omv.common.inout import inform, check_output as co, trim_path, is_verbose
+from omv.engines.engine import OMVEngine
+
+
+class PyneuroConstructEngine(OMVEngine):
+    name = "Py_neuroConstruct"
+
+    @staticmethod
+    def get_nC_environment():
+        nc_path = os.path.join(os.environ["HOME"], "neuroConstruct")
+        if "NC_HOME" in os.environ:
+            nc_path = os.environ["NC_HOME"] + "/"
+
+        environment_vars = {"NC_HOME": nc_path}
+
+        return environment_vars
+
+    @staticmethod
+    def is_installed():
+        nChome = PyneuroConstructEngine.get_nC_environment()["NC_HOME"]
+        inform(
+            "Checking whether neuroConstruct is installed (in %s)" % nChome,
+            indent=2,
+            verbosity=2,
+        )
+        ret = True
+        try:
+            with working_dir(nChome):
+                r = co(["./nC.sh", "-v"], verbosity=1)
+                ret = "v%s" % r.split("neuroConstruct, version: ")[-1].split()[0]
+        except Exception as err:
+            if is_verbose():
+                inform("Couldn't execute neuroConstruct:", err, indent=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.getneuroconstruct import install_neuroconstruct
+
+        inform("Will fetch and install the latest neuroConstruct", indent=2)
+        install_neuroconstruct()
+        inform("Done...", indent=2)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with Py_neuroConstruct" % trim_path(self.modelpath),
+                indent=1,
+            )
+
+            nC_sh = os.path.join(
+                PyneuroConstructEngine.get_nC_environment()["NC_HOME"], "nC.sh"
+            )
+            self.stdout = co(
+                [nC_sh, "-python", self.modelpath, "-nogui"],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            self.returncode = 0
+        except Exception as err:
+            inform("Error with running Py_neuroConstruct:", err, indent=1)
+            self.returncode = -1
+            self.stdout = "???"

omv/engines/pyneuroml_.py

@@ -0,0 +1,55 @@
+import os
+import subprocess as sp
+
+from omv.common.inout import inform, trim_path, is_verbose, check_output
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class PyNeuroMLEngine(OMVEngine):
+    name = "pyNeuroML"
+
+    @staticmethod
+    def is_installed():
+        ret = True
+        try:
+            inform(
+                "Checking whether %s is installed..." % PyNeuroMLEngine.name,
+                indent=1,
+                verbosity=2,
+            )
+            import pyneuroml
+
+            ret = "v%s" % pyneuroml.__version__
+
+        except Exception as err:
+            inform(
+                "Couldn't import %s into Python: " % PyNeuroMLEngine.name,
+                err,
+                indent=1,
+                verbosity=1,
+            )
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.getpyneuroml import install_pynml
+
+        inform("Will fetch and install the latest pyNeuroML", indent=2)
+        install_pynml(version)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                ["pynml" if os.name != "nt" else "pynml.bat", self.modelpath, "-nogui"],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/pyneuromlvalidatesbml.py

@@ -0,0 +1,83 @@
+import os
+import subprocess as sp
+
+from omv.common.inout import inform, trim_path, check_output
+from omv.engines.engine import EngineExecutionError
+from omv.engines.pyneuroml_ import PyNeuroMLEngine 
+from omv.engines.engine import PATH_DELIMITER
+from omv.engines.utils import resolve_paths
+
+class PyNeuroMLValidateSBMLEngine(PyNeuroMLEngine):
+    name = "pyNeuroML_validate_sbml"
+
+    @staticmethod
+    def is_installed():
+        if not PyNeuroMLEngine.is_installed(): return False
+
+        ret = True
+        try:
+            inform(
+                "Checking whether %s is installed..." % PyNeuroMLValidateSBMLEngine.name,
+                indent=1,
+                verbosity=2,
+            )
+            import libsbml
+
+            ret = "v%s" % libsbml.__version__
+
+        except Exception as err:
+            inform(
+                "Couldn't import %s into Python: " % PyNeuroMLValidateSBMLEngine.name,
+                err,
+                indent=1,
+                verbosity=1,
+            )
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        if not PyNeuroMLEngine.is_installed(): PyNeuroMLEngine.install(None)
+
+        from omv.engines.getlibsbml import install_libsbml
+
+        inform("Will fetch and install the latest libsbml", indent=2)
+        install_libsbml(version)
+
+    def run(self):
+        try:
+            path_s = resolve_paths(self.modelpath)
+
+            inform(
+                "Path [%s] expanded to: %s" % (self.modelpath, path_s),
+                indent=1,
+                verbosity=1,
+            )
+
+            #pynml = PyNeuroMLEngine.get_executable() #could implement more flexible way to find the executeable
+            cmds = ["pynml", "-validate-sbml"]
+            for p in path_s:
+                cmds.append(p)
+
+            inform(
+                "Running with %s, using: %s..." % (PyNeuroMLValidateSBMLEngine.name, cmds),
+                indent=1,
+            )
+            self.stdout = check_output(
+                cmds,
+                cwd=os.path.dirname(self.modelpath.split(PATH_DELIMITER)[0])
+                #env=PyNeuroMLEngine.get_environment(),
+            )
+            inform(
+                "Success with running ",
+                PyNeuroMLValidateSBMLEngine.name,
+                indent=1,
+                verbosity=1,
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", PyNeuroMLValidateSBMLEngine.name, indent=1, verbosity=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError
+