OSBModelValidation 0.2.18__py3-none-any.whl

omv/common/inout.py

@@ -0,0 +1,154 @@
+import yaml
+from collections import deque
+import os
+import sys
+
+# import textwrap
+import subprocess as sp
+
+LINEWIDTH = 70
+__PROMPT__ = "[omv] "
+__INDENT__ = "  "
+__VERBOSITY__ = 0
+
+
+def set_verbosity(v):
+    global __VERBOSITY__
+    __VERBOSITY__ = v
+
+
+def omvify(x):
+    # return textwrap.TextWrapper(initial_indent=__PROMPT__,
+    #                             subsequent_indent=len(__PROMPT__) * ' ',
+    #                             replace_whitespace=False).fill(x)
+    return __PROMPT__ + x
+
+
+def check(b):
+    if sys.version_info >= (3, 0):
+        tick = "\u2714" if b else "\u2718"
+    else:
+        tick = "\u2714" if b else "\u2718"
+    return tick
+
+
+def centralize(string):
+    fmt = "{{:^{}}}".format(LINEWIDTH)
+    return fmt.format(string)
+
+
+def rule(string, char="-"):
+    return len(string.lstrip()) * char
+
+
+def is_verbose(level=1):
+    return __VERBOSITY__ >= level
+
+
+def inform(
+    msg, pars=None, indent=0, underline=False, overline=False, center=False, verbosity=0
+):
+    if verbosity > __VERBOSITY__:
+        return
+
+    if isinstance(msg, list):
+        block = deque(msg)
+        infostr = max(msg, key=len)
+    else:
+        p = pars if pars else ""
+        # print("msg is %s"%msg.__class__)
+        msgstr = (
+            msg.encode("utf-8")
+            if sys.version_info[0] == 2 and isinstance(msg, unicode)
+            else str(msg)
+        )
+        infostr = msgstr + str(p)
+        block = deque([infostr])
+
+    if underline:
+        block.append(rule(infostr, underline))
+    if overline:
+        block.appendleft(rule(infostr, overline))
+
+    if center:
+        block = map(centralize, block)
+    if indent:
+        block = map(lambda l: __INDENT__ * indent + l, block)
+
+    print("\n".join(map(omvify, block)))
+
+
+def load_yaml(fname):
+    with open(fname) as f:
+        y = yaml.safe_load(f)
+    return y
+
+
+def trim_path(fname):
+    cwd = os.getcwd()
+    if fname.startswith(cwd):
+        return "." + fname[len(cwd) :]
+    else:
+        return fname
+
+
+def check_output(cmds, cwd=".", shell=False, verbosity=0, env=None):
+    inform(
+        "Running the commands: [%s] in (%s; cwd=%s; shell=%s; env=%s)"
+        % (" ".join(cmds), cwd, os.getcwd(), shell, env),
+        indent=2,
+        verbosity=verbosity,
+    )
+    joint_env = {}
+    if env:
+        joint_env.update(env)
+    for k in os.environ:
+        if not k in joint_env:
+            joint_env[k] = os.environ[k]
+
+    try:
+        ret_string = sp.check_output(
+            cmds, cwd=cwd, shell=shell, env=joint_env, stderr=sp.STDOUT
+        )
+        inform(
+            "Commands: %s completed successfully" % (cmds),
+            indent=2,
+            verbosity=verbosity,
+        )
+        if isinstance(ret_string, bytes):
+            ret_string = ret_string.decode("utf-8")  # For Python 3...
+        return ret_string
+
+    except sp.CalledProcessError as err:
+        inform(
+            "Error running commands: %s in %s (return code: %s)"
+            % (cmds, cwd, err.returncode),
+            indent=2,
+            verbosity=verbosity,
+        )
+        inform("Error: %s" % (err), indent=2, verbosity=verbosity)
+        raise err
+    except Exception as err:
+        inform(
+            "Error running commands: %s in (%s)!" % (cmds, cwd),
+            indent=2,
+            verbosity=verbosity,
+        )
+        inform("Error: %s" % (err), indent=2, verbosity=verbosity)
+        raise err
+
+
+def pip_install(packages, version=None):
+    pip = "pip3" if sys.version_info.major == 3 else "pip"
+    cmds = [pip, "install"]
+    if type(packages) == str:
+        if version == None:
+            cmds.append(packages)
+        else:
+            cmds.append("%s==%s" % (packages, version))
+    else:
+        raise Exception("pip_install will only install single packages...")
+        """
+        for p in packages:
+            cmds.append(p)"""
+    print(check_output(cmds))

omv/engines/__init__.py

@@ -0,0 +1,53 @@
+import inspect
+
+from omv.engines.engine import OMVEngine
+from omv.engines.neuron_ import NeuronEngine
+from omv.engines.jneuroml import JNeuroMLEngine
+from omv.engines.jneuromlnrn import JNeuroMLNRNEngine
+from omv.engines.jneuromlpynnnrn import JNeuroMLPyNNNRNEngine
+from omv.engines.jneuromlnetpyne import JNeuroMLNetPyNEEngine
+from omv.engines.jneuromlnetpyne_np4 import JNeuroMLNetPyNENP4Engine
+from omv.engines.jneuromlnetpyne_np2 import JNeuroMLNetPyNENP2Engine
+
+# from omv.engines.jneuromlbrian import JNeuroMLBrianEngine
+from omv.engines.jneuromleden import JNeuroMLEdenEngine
+from omv.engines.jneuromlbrian2 import JNeuroMLBrian2Engine
+from omv.engines.jneuromlmoose import JNeuroMLMooseEngine
+from omv.engines.jneuromlvalidate import JNeuroMLValidateEngine
+from omv.engines.jneuromlvalidatev1 import JNeuroMLValidateV1Engine
+from omv.engines.jlems import JLemsEngine
+from omv.engines.pylems import PyLemsEngine
+from omv.engines.pylemsnml2 import PyLemsNeuroML2Engine
+from omv.engines.genesis import GenesisEngine
+
+# from omv.engines.brian1 import Brian1Engine
+from omv.engines.brian2_ import Brian2Engine
+from omv.engines.arbor_ import ArborEngine
+from omv.engines.eden_ import EdenEngine
+from omv.engines.nestsli import NestEngine
+from omv.engines.pynest import PyNestEngine
+from omv.engines.moose_ import MooseEngine
+from omv.engines.pynn import PyNNEngine
+from omv.engines.pynnneuron import PyNNNRNEngine
+from omv.engines.pyneuron import PyNRNEngine
+
+# from omv.engines.pynnbrian1 import PyNNBrian1Engine
+from omv.engines.pynnbrian2 import PyNNBrian2Engine
+from omv.engines.pynnnest import PyNNNestEngine
+from omv.engines.pynnneuroml import PyNNNeuroMLEngine
+from omv.engines.octave import OctaveEngine
+from omv.engines.netpyne_ import NetPyNEEngine
+from omv.engines.netpyne__np4 import NetPyNENP4Engine
+from omv.engines.netpyne__np2 import NetPyNENP2Engine
+from omv.engines.pyneuroconstruct import PyneuroConstructEngine
+from omv.engines.pyneuroml_ import PyNeuroMLEngine
+from omv.engines.pyneuromlvalidatesbml import PyNeuroMLValidateSBMLEngine
+
+
+OMVEngines = {
+    be.name: be
+    for be in locals().values()
+    if inspect.isclass(be)
+    and issubclass(be, OMVEngine)
+    and not be.name == "Name not yet set!"
+}

omv/engines/arbor_.py

@@ -0,0 +1,57 @@
+import os
+import subprocess as sp
+
+from omv.common.inout import inform, trim_path, check_output
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class ArborEngine(OMVEngine):
+    name = "Arbor"
+
+    @staticmethod
+    def is_installed():
+        ret = True
+        try:
+            import arbor
+
+            inform(
+                "Arbor version %s is correctly installed..." % arbor.__version__,
+                indent=2,
+                verbosity=2,
+            )
+
+            ret = "v%s" % arbor.__version__
+
+        except Exception as err:
+            inform("Couldn't import Arbor into Python: ", err, indent=1, verbosity=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.getarbor import install_arbor
+
+        home = os.environ["HOME"]
+        inform("Will fetch and install the latest Arbor", indent=2)
+        install_arbor(version)
+        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(
+                ["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/brian1.py

@@ -0,0 +1,59 @@
+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 Brian1Engine(OMVEngine):
+    name = "Brian"
+
+    python3_compatible = False
+
+    @staticmethod
+    def is_installed():
+        ret = False
+        try:
+            import brian
+
+            if is_verbose():
+                inform(
+                    "Brian version %s is correctly installed..." % brian.__version__,
+                    indent=2,
+                )
+
+            ret = "v%s" % brian.__version__
+
+        except Exception as err:
+            inform("Couldn't import Brian into Python: ", err, indent=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.getbrian1 import install_brian
+
+        home = os.environ["HOME"]
+        inform("Will fetch and install the latest Brian (version 1.x)", indent=2)
+        install_brian()
+        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(
+                ["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/brian2_.py

@@ -0,0 +1,57 @@
+import os
+import subprocess as sp
+
+from omv.common.inout import inform, trim_path, check_output
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class Brian2Engine(OMVEngine):
+    name = "Brian2"
+
+    @staticmethod
+    def is_installed():
+        ret = True
+        try:
+            import brian2
+
+            inform(
+                "Brian2 version %s is correctly installed..." % brian2.__version__,
+                indent=2,
+                verbosity=2,
+            )
+
+            ret = "v%s" % brian2.__version__
+
+        except Exception as err:
+            inform("Couldn't import Brian2 into Python: ", err, indent=1, verbosity=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.getbrian2 import install_brian2
+
+        home = os.environ["HOME"]
+        inform("Will fetch and install the latest Brian (version 2.x)", indent=2)
+        install_brian2(version)
+        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(
+                ["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/eden_.py

@@ -0,0 +1,63 @@
+import os
+import subprocess as sp
+
+from omv.common.inout import inform, trim_path, check_output
+from omv.engines.engine import OMVEngine, EngineExecutionError
+from omv.engines.geteden import DEFAULT_VERSION
+
+
+class EdenEngine(OMVEngine):
+    name = "EDEN"
+
+    @staticmethod
+    def is_installed():
+        ret = True
+        try:
+            import eden_simulator
+
+            ver = "v%s" % (
+                eden_simulator.__version__
+                if hasattr(eden_simulator, "__version__")
+                else "???"
+            )
+            inform(
+                "EDEN version %s is correctly installed..." % ver, indent=2, verbosity=2
+            )
+
+            ret = ver
+
+        except Exception as err:
+            inform("Couldn't import EDEN into Python: ", err, indent=1, verbosity=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.geteden import install_eden
+
+        home = os.environ["HOME"]
+        inform("Will fetch and install the latest EDEN", indent=2)
+        install_eden(version)
+        inform("Done...", indent=2)
+
+    def run(self):
+        try:
+            inform(
+                "Running a file %s with the simulator %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/engine.py

@@ -0,0 +1,111 @@
+from os.path import realpath
+from os import environ
+import sys
+from omv.common.inout import inform
+import platform
+
+PATH_DELIMITER = ";"
+
+
+class EngineInstallationError(Exception):
+    pass
+
+
+class EngineExecutionError(Exception):
+    pass
+
+
+class OMVEngine(object):
+    name = "Name not yet set!"
+    environment_vars = {}
+    path = ""
+
+    python3_compatible = True  # Most are so override only in those that aren't
+
+    def __init__(self, target, do_not_check_install, engine_version=None):
+        if not do_not_check_install:
+            inform(
+                "Checking whether OMVEngine: %s is already installed..." % (self.name),
+                indent=1,
+                verbosity=1,
+            )
+            if not self.is_installed():
+                try:
+                    if (
+                        platform.python_version_tuple()[0] == "3"
+                        and not self.python3_compatible
+                    ):
+                        inform(
+                            "Not installing %s due to Python 3 incompatibility. Tests will throw error unless option --ignore-non-py3 specified"
+                            % self.name
+                        )
+                    else:
+                        self.install(engine_version)
+                        self.set_environment()
+                        self.set_path()
+                except Exception as e:
+                    inform("Installation err: %s" % e)
+                    raise (EngineInstallationError(e))
+            """
+            if not self.is_installed(engine_version):  # Still
+                inform("Fatal installation error for: %s"%self.name)
+                exit(1)"""
+
+        if " " in target:
+            all = ""
+            for mp in target.split():
+                all += realpath(mp) + PATH_DELIMITER
+            self.modelpath = all[:-1]
+        else:
+            self.modelpath = realpath(target)
+        self.extra_pars = []
+
+    def __str__(self):
+        return self.name
+
+    def is_installed(self):
+        raise NotImplementedError()
+
+    def run(self):
+        raise NotImplementedError()
+
+    def install(self, version):
+        raise NotImplementedError()
+
+    def build_query_string(self, name, cmd):
+        raise NotImplementedError()
+
+    def set_environment(self):
+        if self.environment_vars:
+            for name, val in self.environment_vars.items():
+                if name in environ and not "HOME" in name:
+                    if not ":%s:" % val in environ[name]:
+                        environ[name] = "%s:%s" % (environ[name], val)
+                else:
+                    environ[name] = val
+                inform("Set env var %s: " % name, environ[name], indent=2, verbosity=1)
+
+    def set_path(self):
+        if self.path:
+            environ["PATH"] = ":".join((environ["PATH"], self.path))
+            inform("Setting PATH: ", environ["PATH"], indent=2, verbosity=1)
+
+    def register_query(self, name, cmd=""):
+        query = self.build_query_string(name, cmd)
+        inform("Registered engine query: ", query, indent=2, verbosity=1)
+        self.extra_pars.append(query)
+        return name
+
+    def fetch_query(self, key):
+        import re
+
+        match_float = "\s*([0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s*"
+
+        l = key + ":" + match_float
+
+        m = re.search(l, self.stdout)
+        if m:
+            return m.groups()[0]
+        else:
+            inform("Not found!")
+            raise KeyError

omv/engines/genesis.py

@@ -0,0 +1,86 @@
+import re
+import os
+import subprocess as sp
+from tempfile import NamedTemporaryFile
+
+from omv.engines.engine import OMVEngine, EngineExecutionError
+from omv.engines.utils.wdir import working_dir
+from omv.common.inout import inform
+
+
+class GenesisEngine(OMVEngine):
+    name = "genesis"
+
+    @classmethod
+    def is_installed(cls, version=None):
+        from tempfile import NamedTemporaryFile
+
+        ret = True
+        try:
+            temp = NamedTemporaryFile(suffix=".g")
+            temp.writelines([b'echo "version: "{version} \n', b"quit \n"])
+            temp.seek(0)
+            out = sp.check_output(["genesis", "-nox", "-batch", "-notty", temp.name])
+            m = re.search(b"version:\s*([0-9]*\.?[0-9]+)\s*", out)
+            if m:
+                ver = m.groups()[0]
+
+                if isinstance(ver, bytes):
+                    ver = ver.decode("utf-8")
+                ret = "v%s" % ver
+                inform("Found GENESIS in path, version %s" % ret, verbosity=1, indent=2)
+        except OSError:
+            ret = False
+        finally:
+            temp.close()
+
+        return ret
+
+    @classmethod
+    def install(cls, engine_version):
+        from omv.engines.getgenesis import install_genesis
+
+        home = os.environ["HOME"]
+        cls.path = os.path.join(home, "genesis", "genesis2.4gamma-master", "src")
+        inform("Will fetch and install genesis-2.4", indent=1)
+        install_genesis()
+
+    def run(self):
+        from pkg_resources import resource_filename
+
+        with working_dir(os.path.dirname(self.modelpath)):
+            try:
+                temp = NamedTemporaryFile(suffix=".g", mode="w")
+                temp.write("include %s\n" % self.modelpath)
+                temp.write(
+                    "include %s\n"
+                    % resource_filename("omv", "engines/utils/genesis_utils.g")
+                )
+                temp.write("\n".join(self.extra_pars) + "\n")
+                temp.seek(0)
+
+                with open("/tmp/omv.gen.err", "w+") as se:
+                    self.stdout = sp.check_output(
+                        ["genesis", "-nox", "-batch", "-notty", temp.name], stderr=se
+                    )
+                    se.seek(0)
+                    self.stderr = se.readlines()
+                self.returncode = 0
+            except sp.CalledProcessError as e:
+                self.returncode = e.returncode
+                raise EngineExecutionError
+            finally:
+                temp.close()
+
+    def build_query_string(self, name, cmd):
+        return "echo %s: {%s}" % (name, cmd)
+
+    def query_area(self, secname):
+        name = self.register_query(
+            "area_%s" % secname.translate(None, "/[]"),
+            "total_membrane_area %s" % secname,
+        )
+        return name
+
+    def query_temperature(self):
+        return self.register_query("temperature", "celsius")

omv/engines/getarbor.py

@@ -0,0 +1,15 @@
+from omv.common.inout import pip_install
+
+
+def install_arbor(version=None):
+    if not version:
+        version = "0.9.0"
+    try:
+        pip_install("arbor==%s" % version)
+        import arbor
+
+        m = "Successfully installed Arbor..."
+    except Exception as e:
+        m = "ERROR installing Arbor: " + str(e)
+    finally:
+        print(m)