OSBModelValidation 0.2.18__py3-none-any.whl

omv/engines/jneuromlvalidate.py

@@ -0,0 +1,62 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuroml import JNeuroMLEngine, EngineExecutionError
+from omv.common.inout import inform, check_output
+from omv.engines.engine import PATH_DELIMITER
+from omv.engines.utils import resolve_paths
+
+class JNeuroMLValidateEngine(JNeuroMLEngine):
+    name = "jNeuroML_validate"
+
+    @staticmethod
+    def is_installed():
+        return JNeuroMLEngine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not JNeuroMLEngine.is_installed():
+            JNeuroMLEngine.install(None)
+
+        JNeuroMLValidateEngine.path = JNeuroMLEngine.path
+        JNeuroMLValidateEngine.environment_vars = {}
+        JNeuroMLValidateEngine.environment_vars.update(JNeuroMLEngine.environment_vars)
+
+    def run(self):
+        try:
+            path_s = resolve_paths(self.modelpath)
+
+            inform(
+                "Path [%s] expanded to: %s" % (self.modelpath, path_s),
+                indent=1,
+                verbosity=1,
+            )
+
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+            cmds = [jnml, "-validate"]
+            for p in path_s:
+                cmds.append(p)
+
+            inform(
+                "Running with %s, using: %s..." % (JNeuroMLValidateEngine.name, cmds),
+                indent=1,
+            )
+            self.stdout = check_output(
+                cmds,
+                cwd=os.path.dirname(self.modelpath.split(PATH_DELIMITER)[0]),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            inform(
+                "Success with running ",
+                JNeuroMLValidateEngine.name,
+                indent=1,
+                verbosity=1,
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", JNeuroMLValidateEngine.name, indent=1, verbosity=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/jneuromlvalidatev1.py

@@ -0,0 +1,58 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuroml import JNeuroMLEngine, EngineExecutionError
+from omv.engines.jneuromlvalidate import resolve_paths
+
+from omv.common.inout import inform
+
+
+class JNeuroMLValidateV1Engine(JNeuroMLEngine):
+    name = "jNeuroML_validatev1"
+
+    @staticmethod
+    def is_installed():
+        return JNeuroMLEngine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not JNeuroMLEngine.is_installed():
+            JNeuroMLEngine.install(None)
+
+        JNeuroMLValidateV1Engine.path = JNeuroMLEngine.path
+        JNeuroMLValidateV1Engine.environment_vars = {}
+        JNeuroMLValidateV1Engine.environment_vars.update(
+            JNeuroMLEngine.environment_vars
+        )
+
+    def run(self):
+        try:
+            path_s = resolve_paths(self.modelpath)
+
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+            cmds = [jnml, "-validatev1"]
+            for p in path_s:
+                cmds.append(p)
+
+            inform(
+                "Running with %s, using %s..." % (JNeuroMLValidateV1Engine.name, cmds),
+                indent=1,
+            )
+            self.stdout = sp.check_output(
+                cmds,
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            inform(
+                "Success with running ",
+                JNeuroMLValidateV1Engine.name,
+                indent=1,
+                verbosity=1,
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/moose_.py

@@ -0,0 +1,86 @@
+import os
+import subprocess as sp
+
+from omv.engines.pyneuroml_ import PyNeuroMLEngine
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class MooseEngine(OMVEngine):
+    name = "Moose"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether the engine %s has been installed correctly..."
+                % MooseEngine.name,
+                indent=1,
+            )
+
+        ret = True
+        try:
+            ret_str = sp.check_output(
+                ['python -c "import moose; print(moose.__version__)"'],
+                shell=True,
+                stderr=sp.STDOUT,
+            )
+            ret = len(ret_str) > 0
+
+            if isinstance(ret_str, bytes):
+                ret_str = ret_str.decode("utf-8").strip()
+
+            if ret and is_verbose():
+                inform(
+                    "%s is correctly installed (%s)..." % (MooseEngine.name, ret_str),
+                    indent=2,
+                )
+            if ret:
+                # import moose
+                ret = "v%s" % ret_str
+
+        except Exception as err:
+            if is_verbose():
+                inform("Couldn't import moose into Python: ", err, indent=1)
+            ret = False
+        if not ret or not PyNeuroMLEngine.is_installed():
+            ret = False
+
+        inform("Moose is_installed(): %s" % ret, "", indent=1, verbosity=2)
+        return ret
+
+    @staticmethod
+    def install(version):
+        if not PyNeuroMLEngine.is_installed():
+            PyNeuroMLEngine.install(None)
+            inform(
+                "%s installed PyNeuroML..." % MooseEngine.name, indent=2, verbosity=1
+            )
+
+        from omv.engines.getmoose import install_moose
+
+        home = os.environ["HOME"]
+        inform("Will fetch and install the latest Moose..", indent=2)
+        install_moose(version)
+        inform("Done, Moose 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, "-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/nestsli.py

@@ -0,0 +1,84 @@
+import os
+import sys
+
+import subprocess as sp
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class NestEngine(OMVEngine):
+    name = "NEST"
+
+    @staticmethod
+    def get_nest_environment():
+        nestpath = os.path.join(os.environ["HOME"], "nest/nest/")
+        if "NEST_INSTALL_DIR" in os.environ:
+            nestpath = os.environ["NEST_INSTALL_DIR"] + "/"
+        elif "NEST_HOME" in os.environ:
+            nestpath = os.environ["NEST_HOME"] + "/"
+
+        environment_vars = {
+            "NEST_HOME": nestpath,
+            "PYTHONPATH": nestpath
+            + "/lib/python%s.%s/site-packages/"
+            % (sys.version_info.major, sys.version_info.minor),
+        }
+
+        return environment_vars
+
+    @staticmethod
+    def is_installed():
+        ret = True
+        environment_vars = NestEngine.get_nest_environment()
+        try:
+            FNULL = open(os.devnull, "w")
+
+            r = check_output(
+                [environment_vars["NEST_HOME"] + "bin/nest", "-v"], verbosity=2
+            )
+
+            ret = "%s" % r.split("version")[1].split()[0][:-1]
+            if "-" in ret:
+                ret = "v%s" % ret.split("-")[-1]
+
+            if not "v" in ret:
+                ret = "v%s" % ret
+
+            inform("NEST %s is correctly installed..." % ret, indent=2, verbosity=1)
+
+        except OSError as err:
+            if is_verbose():
+                inform("Couldn't execute NEST: ", err, indent=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.getnest import install_nest
+
+        install_nest(version)
+        inform("Done...", indent=2)
+
+    def run(self):
+        self.environment_vars = NestEngine.get_nest_environment()
+        self.set_environment()
+
+        try:
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+            self.stdout = check_output(
+                [self.environment_vars["NEST_HOME"] + "bin/nest", 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/netpyne_.py

@@ -0,0 +1,120 @@
+import os
+import subprocess as sp
+
+from omv.engines.pyneuron import PyNRNEngine
+from omv.engines.pyneuroml_ import PyNeuroMLEngine
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class NetPyNEEngine(OMVEngine):
+    name = "NetPyNE"
+
+    @staticmethod
+    def is_installed(silent=True):
+        if is_verbose():
+            inform(
+                "Checking whether the engine %s has been installed correctly..."
+                % NetPyNEEngine.name,
+                indent=1,
+            )
+
+        ret = True
+        try:
+            ret_str = sp.check_output(
+                ['python -c "import netpyne; print(netpyne.__version__)"'],
+                shell=True,
+                stderr=sp.STDOUT,
+            )
+
+            ret = len(ret_str) > 0
+
+            if isinstance(ret_str, bytes):
+                ret_str = ret_str.decode("utf-8")
+
+            ret_str = ret_str.strip().split("\n")[
+                -1
+            ]  # in case multiple lines (with warning) returned
+
+            if ret and is_verbose():
+                inform("%s is correctly installed..." % (NetPyNEEngine.name), indent=2)
+
+            if ret:
+                ret = "v%s" % str(ret_str.strip())
+
+        except Exception as err:
+            if not silent:
+                inform("Couldn't import netpyne into Python: ", err, indent=1)
+            ret = False
+
+        if not PyNRNEngine.is_installed() or not PyNeuroMLEngine.is_installed():
+            ret = False
+
+        if not silent:
+            inform("NetPyNE is_installed: %s" % ret, "", indent=1)
+        return ret
+
+    @staticmethod
+    def install(version):
+        if not PyNRNEngine.is_installed():
+            PyNRNEngine.install(None)
+            inform(
+                "%s installed PyNEURON..." % NetPyNEEngine.name, indent=2, verbosity=1
+            )
+
+        if not PyNeuroMLEngine.is_installed():
+            PyNeuroMLEngine.install(None)
+            inform(
+                "%s installed PyNeuroML..." % NetPyNEEngine.name, indent=2, verbosity=1
+            )
+
+        from omv.engines.getnetpyne import install_netpyne
+
+        home = os.environ["HOME"]
+        inform("Will fetch and install the latest NetPyNE..", indent=2)
+        install_netpyne()
+        inform("Done, NetPyNE is correctly installed...", indent=2)
+
+        NetPyNEEngine.path = PyNRNEngine.path
+        NetPyNEEngine.environment_vars = {}
+        NetPyNEEngine.environment_vars.update(PyNRNEngine.environment_vars)
+
+        inform("PATH: " + NetPyNEEngine.path, indent=2, verbosity=1)
+        inform("Env vars: %s" % NetPyNEEngine.environment_vars, indent=2, verbosity=1)
+
+        environment_vars, path = PyNRNEngine.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 = PyNRNEngine.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, "-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/netpyne__np2.py

@@ -0,0 +1,47 @@
+import os
+import subprocess as sp
+
+from omv.engines.pyneuron import PyNRNEngine
+from omv.engines.netpyne_ import NetPyNEEngine
+
+from omv.common.inout import inform, trim_path, check_output
+from omv.engines.engine import EngineExecutionError
+
+"""
+    A temporary engine for testing running NetPyNE models in parallel mode.
+    Would require update of NEURON installation process to ensure parallel 
+    NEURON correctly installed, so mainly useful for local testing presently.
+    Would also be better to incorporate this into netpyne_.py, and have correct 
+    handling of variables specified in *.omt files
+"""
+
+
+class NetPyNENP2Engine(NetPyNEEngine):
+    name = "NetPyNE_NP2"
+
+    def run(self):
+        try:
+            self.stdout = PyNRNEngine.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(
+                ["mpiexec", "-np", "2", "nrniv", "-mpi", 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/netpyne__np4.py

@@ -0,0 +1,47 @@
+import os
+import subprocess as sp
+
+from omv.engines.pyneuron import PyNRNEngine
+from omv.engines.netpyne_ import NetPyNEEngine
+
+from omv.common.inout import inform, trim_path, check_output
+from omv.engines.engine import EngineExecutionError
+
+"""
+    A temporary engine for testing running NetPyNE models in parallel mode.
+    Would require update of NEURON installation process to ensure parallel 
+    NEURON correctly installed, so mainly useful for local testing presently.
+    Would also be better to incorporate this into netpyne_.py, and have correct 
+    handling of variables specified in *.omt files
+"""
+
+
+class NetPyNENP4Engine(NetPyNEEngine):
+    name = "NetPyNE_NP4"
+
+    def run(self):
+        try:
+            self.stdout = PyNRNEngine.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(
+                ["mpiexec", "-np", "4", "nrniv", "-mpi", 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 = "???"