OSBModelValidation 0.2.18__py3-none-any.whl

omv/find_tests.py

@@ -0,0 +1,126 @@
+from os import environ, getcwd
+from pathlib import Path
+from omv.parse_omt import parse_omt
+from omv.common.inout import load_yaml, inform, trim_path, is_verbose
+from omv.tally import TallyHolder
+from omv.engines import OMVEngines
+
+
+def test_all(
+    do_not_run=False,
+    only_this_engine=None,
+    include_temp_tests=False,
+    ignore_non_py3=False,
+):
+    cwd = Path(getcwd())
+    all_omts = [p.as_posix() for p in cwd.glob("**/*.omt")]
+    if include_temp_tests:
+        all_omts += [p.as_posix() for p in cwd.glob("**/*.omt_")]
+
+    th = TallyHolder()
+    if environ.get("TRAVIS"):
+        if not environ.get("OMV_ENGINE"):
+            tallies = [parse_omt(t, ignore_non_py3=ignore_non_py3) for t in all_omts]
+        else:
+            engine = environ.get("OMV_ENGINE").lower()
+            engine_version = None
+            if ":" in engine:
+                ee = engine.split(":")
+                engine = ee[0]
+                engine_version = ee[1]
+            tallies = [
+                parse_omt(
+                    t, engine_version=engine_version, ignore_non_py3=ignore_non_py3
+                )
+                for t in all_omts
+                if load_yaml(t)["engine"].lower() == engine
+            ]
+    elif only_this_engine:
+        inform("Only running tests for engine: %s" % only_this_engine)
+        tallies = [
+            parse_omt(t, ignore_non_py3=ignore_non_py3)
+            for t in all_omts
+            if load_yaml(t)["engine"].lower() == only_this_engine.lower()
+        ]
+    else:
+        tallies = []
+        failed = 0
+        for i in range(len(all_omts)):
+            t = all_omts[i]
+            inform("")
+            tally = parse_omt(t, do_not_run, ignore_non_py3=ignore_non_py3)
+            if not tally.all_passed():
+                failed += 1
+            if not do_not_run:
+                inform("")
+                inform("")
+                inform(
+                    "      [ Test %i of %i complete - failed so far: %s ]"
+                    % (i + 1, len(all_omts), failed)
+                )
+            tallies.append(tally)
+
+    tallies.sort()
+
+    if not do_not_run:
+        for t in tallies:
+            th.add(t)
+
+        results = []
+        for i in range(len(tallies)):
+            t = tallies[i]
+            results.append(t.all_passed())
+        inform("")
+        inform(
+            "%i test(s) run" % len(tallies), overline="-", underline="-", center=True
+        )
+        inform("")
+        if len(results) == 0:
+            inform("No tests found!", underline="=", center=True)
+        elif all(results):
+            inform("All tests passing!", underline="=", center=True)
+        else:
+            failed = [trim_path(t.omt) for t in tallies if not t.all_passed()]
+            inform("Some test(s) failed: ", failed, underline="=")
+
+        if is_verbose():
+            print("\n" + th.summary() + "\n")
+
+        assert len(results) > 0
+        assert all(results)
+
+    else:
+        engs = {}
+        tot_tests = 0
+        for t in tallies:
+            if not t.engine in engs:
+                engs[t.engine] = 0
+            engs[t.engine] += 1
+            tot_tests += 1
+        inform("")
+
+        for e in sorted(engs):
+            inform(
+                "  Engine %s %s tests\t(installed: %s)"
+                % (e + ":" + " " * (21 - len(e)), engs[e], OMVEngines[e].is_installed())
+            )
+
+        inform("")
+        inform("  %s OMV tests in total" % (tot_tests))
+        inform("")
+
+
+def test_one(omt_fname):
+    tally = parse_omt(omt_fname)
+    inform("")
+    if tally.all_passed():
+        inform("Test passed: %s" % omt_fname, overline="=", center=True)
+    else:
+        inform("Test failed: %s" % (omt_fname), underline="=", center=True)
+
+    if is_verbose():
+        th = TallyHolder()
+        th.add(tally)
+        print("\n" + th.summary() + "\n")
+
+    assert tally.all_passed()

omv/omt_mep_parser.py

@@ -0,0 +1,59 @@
+from omv.experiment import OMVExperiment
+from os.path import join, dirname
+from omv.common.inout import load_yaml
+
+
+class OMVParseError(BaseException):
+    pass
+
+
+class OMVTestParser(object):
+    def __init__(self, omt_path):
+        self.omt_path = omt_path
+        self.omt_root = dirname(omt_path)
+        self.omt = load_yaml(omt_path)
+        if "mep" in self.omt:
+            self.mep_path = join(self.omt_root, self.omt["mep"])
+            self.mep_root = dirname(self.mep_path)
+            self.mep = load_yaml(self.mep_path)
+        else:
+            self.mep_root = None
+            self.mep_path = None
+            self.mep = None
+
+    @property
+    def modelpath(self):
+        # print('Interpreting %s'%self.omt['target'])
+        if " " in self.omt["target"]:  # e.g. target: "*.cell.nml *.channel.nml"
+            all = ""
+            for part in self.omt["target"].split(" "):
+                all += join(self.omt_root, part.strip()) + " "
+            return all[:-1]
+        return join(self.omt_root, self.omt["target"])
+
+    @property
+    def engine(self):
+        return self.omt["engine"]
+
+    @property
+    def mep_experiments(self):
+        return self.mep["experiments"]
+
+    @property
+    def omt_experiments(self):
+        return self.omt["experiments"]
+
+    def generate_exps(self, engine):
+        if self.mep:
+            for expname, exp in self.omt_experiments.items():
+                expmep = self.mep_experiments[expname]
+                obs = exp["observables"]
+                yield OMVExperiment(
+                    expname, expmep, obs, engine, self.omt_root, self.mep_root
+                )
+        else:
+            exp = {"expected": {"dry": None}}
+            obs = {"dry": None}
+            yield OMVExperiment(
+                "Dry run", exp, obs, engine, self.omt_root, self.mep_root
+            )

omv/omv_util.py

@@ -0,0 +1,439 @@
+"""OpenSourceBrain Model Validation and Testing
+============================================
+
+  Usage:
+    omv all [-V | --verbose] [--engine=engine] [--ignore-non-py3]
+    omv all_ [-V | --verbose] [--engine=engine]
+    omv test <testMe.omt> [-V | --verbose]
+    omv autogen [options]
+    omv install <engine>
+    omv find
+    omv (list-engines | list) [-V | --verbose]
+    omv validate-mep <mepfile>
+    omv validate-omt <omtfile>
+    omv (-h | --help)
+    omv --version
+
+  Options:
+    -h --help         Show this screen.
+    -d --dryrun       Generate dry-run tests only [default: False].
+    -V --verbose      Display additional diagnosis messages [default: False].
+    --version         Show version.
+    --ignore-non-py3  If Python 3, ignore tests on non Py3 compatible engines [default: False]
+    -y                Auto-select default options (non-interactive mode)
+"""
+from docopt import docopt
+from omv.find_tests import test_all, test_one
+from omv.validation import validate_mep
+from omv.autogen import autogen
+from omv.engines import OMVEngines
+from omv.common.inout import inform
+import os
+import platform
+
+from omv.common.inout import set_verbosity
+
+from omv import __version__ as omv_version
+
+
+def main():
+    arguments = docopt(
+        __doc__, version="OpenSourceBrain Model Validation %s" % omv_version
+    )
+    set_env_vars()
+
+    if arguments["--verbose"]:
+        set_verbosity(1)
+
+    if arguments["test"]:
+        try:
+            test_one(arguments["<testMe.omt>"])
+        except AssertionError:
+            inform("Failed due to non passing tests")
+            exit(1)
+
+    elif arguments["all"]:
+        try:
+            if platform.python_version_tuple()[0] == "3":
+                inform(
+                    "Python 3. Ignoring tests for non Py3 compatible engines: %s"
+                    % arguments["--ignore-non-py3"]
+                )
+
+            if arguments["--engine"] is not None:
+                if ":" in arguments["--engine"]:
+                    _install_engine(arguments["--engine"])
+                only_this_engine = arguments["--engine"].split(":")[0]
+            else:
+                only_this_engine = None
+
+            test_all(
+                only_this_engine=only_this_engine,
+                ignore_non_py3=arguments["--ignore-non-py3"],
+            )
+        except AssertionError:
+            inform("Failed due to non passing tests")
+            exit(1)
+
+    # Includes *.omt_, i.e. temporary test files
+    elif arguments["all_"]:
+        try:
+            test_all(
+                only_this_engine=arguments["--engine"],
+                include_temp_tests=True,
+                ignore_non_py3=arguments["--ignore-non-py3"],
+            )
+        except AssertionError:
+            inform("Failed due to non passing tests")
+            exit(1)
+
+    elif arguments["find"]:
+        try:
+            test_all(do_not_run=True)
+        except AssertionError:
+            inform("Failed due to non passing tests")
+            exit(1)
+
+    elif arguments["validate-mep"]:
+        validate_mep.validate(arguments["<mepfile>"])
+
+    elif arguments["validate-omt"]:
+        inform("OMT validation not implemented yet!")
+        exit(1)
+
+    elif arguments["install"]:
+        set_verbosity(1)
+        eng = arguments["<engine>"]
+
+        _install_engine(eng)
+
+    elif arguments["list-engines"] or arguments["list"]:
+        inform("OMV is checking which engines are currently installed...")
+        set_verbosity(0)  # No need to report failures
+        engines = sorted(OMVEngines.keys())
+
+        installed = {}
+        for engine in engines:
+            installed[engine] = OMVEngines[engine].is_installed()
+
+        inform("")
+        inform(
+            "The following engines are currently supported by OMV (v%s):" % omv_version
+        )
+        inform("")
+        for engine in engines:
+            py3_info = (
+                "" if OMVEngines[engine].python3_compatible else "; non Py3 compatible"
+            )
+            inform(
+                "  %s%s(installed: %s%s)"
+                % (engine, " " * (30 - len(engine)), installed[engine], py3_info)
+            )
+        inform("")
+        if arguments["--verbose"]:
+            inform("Additional Python (v%s) packages:" % platform.python_version())
+            inform("")
+            for m in [
+                "matplotlib",
+                "numpy",
+                "pandas",
+                "scipy",
+                "sympy",
+                "tables",
+                "h5py",
+                "neo",
+                "lazyarray",
+                "pyelectro",
+                "neurotune",
+                "lems",
+                "pyneuroml",
+                "neuroml",
+                "neuromllite",
+                "libsbml",
+            ]:
+                installed_ver = False
+                try:
+                    exec("import %s" % m)
+                    installed_ver = "v%s" % eval("%s.__version__" % m)
+                except:
+                    pass
+                inform(
+                    "  %s%s(installed: %s)" % (m, " " * (30 - len(m)), installed_ver)
+                )
+            inform("")
+
+    elif arguments["autogen"]:
+        inform("Automatically generating model validation files")
+        dry = arguments["--dryrun"]
+        auto = arguments["-y"]
+        autogen(auto, dry)
+
+
+def _install_engine(eng):
+    engine_version = None
+
+    if ":" in eng:
+        ee = eng.split(":")
+        eng = ee[0]
+        engine_version = ee[1]
+        inform("Engine %s version %s will be used..." % (eng, engine_version))
+    else:
+        inform("Engine %s, default version will be used..." % (eng))
+
+    if eng.lower() not in [e.lower() for e in OMVEngines]:
+        inform("Engine " + eng + " unknown!")
+    else:
+        inform("Trying to install: %s" % eng)
+        already_installed = False
+
+        if eng.lower() == "NEURON".lower():
+            from omv.engines.neuron_ import NeuronEngine
+
+            if not NeuronEngine.is_installed():
+                from omv.engines.getnrn import install_neuron
+
+                install_neuron(engine_version)
+            else:
+                already_installed = True
+
+        elif eng.lower() == "PyNEURON".lower():
+            from omv.engines.pyneuron import PyNRNEngine
+
+            if not PyNRNEngine.is_installed():
+                from omv.engines.getnrn import install_neuron
+
+                install_neuron(engine_version)
+            else:
+                already_installed = True
+
+        elif eng.lower() == "jLEMS".lower():
+            from omv.engines.jlems import JLemsEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                if engine_version is not None:
+                    raise Exception(
+                        "Currently, cannot install a specific version of engine %s"
+                        % eng
+                    )
+                from omv.engines.getjlems import install_jlems
+
+                install_jlems()
+
+        elif eng.lower() == "jNeuroML".lower():
+            from omv.engines.jneuroml import JNeuroMLEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                from omv.engines.getjnml import install_jnml
+
+                install_jnml(engine_version)
+
+        elif eng.lower() == "neuroConstruct" or eng == "Py_neuroConstruct".lower():
+            from omv.engines.pyneuroconstruct import PyneuroConstructEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                if engine_version is not None:
+                    raise Exception(
+                        "Currently, cannot install a specific version of engine %s"
+                        % eng
+                    )
+                from omv.engines.getneuroconstruct import install_neuroconstruct
+
+                install_neuroconstruct()
+
+        elif eng.lower() == "pyNeuroML".lower():
+            from omv.engines.pyneuroml_ import PyNeuroMLEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                ee.install(engine_version)
+
+        elif eng.lower() == "PyLEMS".lower():
+            from omv.engines.pylems import PyLemsEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                if engine_version is not None:
+                    raise Exception(
+                        "Currently, cannot install a specific version of engine %s"
+                        % eng
+                    )
+                from omv.engines.getpylems import install_pylems
+
+                install_pylems()
+
+        elif eng.lower() == "Arbor".lower():
+            from omv.engines.arbor_ import ArborEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                from omv.engines.getarbor import install_arbor
+
+                install_arbor(engine_version)
+
+        elif eng.lower() == "EDEN".lower():
+            from omv.engines.eden_ import EdenEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                from omv.engines.geteden import install_eden
+
+                install_eden(engine_version)
+
+        elif eng.lower() == "PyLEMS_NeuroML2".lower():
+            pylems_already_installed = False
+            nml2_already_installed = False
+
+            from omv.engines.pylems import PyLemsEngine as ee
+
+            if ee.is_installed():
+                pylems_already_installed = True
+            else:
+                from omv.engines.getpylems import install_pylems
+
+                install_pylems()
+
+            from omv.engines.getnml2 import install_nml2, is_nml2_installed
+
+            if is_nml2_installed():
+                nml2_already_installed = True
+            else:
+                if engine_version is not None:
+                    raise Exception(
+                        "Currently, cannot install a specific version of engine %s"
+                        % eng
+                    )
+                install_nml2()
+
+            already_installed = nml2_already_installed and pylems_already_installed
+
+        elif eng.lower() == "Py_neuroConstruct".lower():
+            from omv.engines.pyneuroconstruct import PyneuroConstructEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                if engine_version is not None:
+                    raise Exception(
+                        "Currently, cannot install a specific version of engine %s"
+                        % eng
+                    )
+                from omv.engines.getneuroconstruct import install_neuroconstruct
+
+                install_neuroconstruct()
+
+        elif eng.lower() == "genesis".lower():
+            if engine_version is not None:
+                raise Exception(
+                    "Currently, cannot install a specific version of engine %s" % eng
+                )
+            from omv.engines.getgenesis import install_genesis
+
+            install_genesis()
+        elif eng.lower() == "Moose".lower():
+            if engine_version is not None:
+                raise Exception(
+                    "Currently, cannot install a specific version of engine %s" % eng
+                )
+            from omv.engines.getmoose import install_moose
+
+            install_moose(engine_version)
+        elif eng.lower() == "NetPyNE".lower():
+            from omv.engines.getnetpyne import install_netpyne
+
+            install_netpyne(engine_version)
+        elif eng.lower() == "Brian".lower():
+            if engine_version is not None:
+                raise Exception(
+                    "Currently, cannot install a specific version of engine %s" % eng
+                )
+            from omv.engines.getbrian1 import install_brian
+
+            install_brian()
+        elif eng.lower() == "Brian2".lower():
+            from omv.engines.getbrian2 import install_brian2
+
+            install_brian2(engine_version)
+        elif eng.lower() == "NEST".lower():
+            from omv.engines.nestsli import NestEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                from omv.engines.getnest import install_nest
+
+                install_nest(engine_version)
+        elif eng.lower() == "PyNEST".lower():
+            from omv.engines.pynest import PyNestEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                from omv.engines.getnest import install_nest
+
+                install_nest(engine_version)
+        elif eng.lower() == "PyNN".lower():
+            from omv.engines.getpynn import install_pynn
+
+            install_pynn(engine_version)
+
+        elif eng.lower() == "PyNN_NEURON".lower():
+            if engine_version is not None:
+                raise Exception(
+                    "Currently, cannot install a specific version of engine %s" % eng
+                )
+            from omv.engines.pynnneuron import PyNNNRNEngine
+
+            PyNNNRNEngine.install()
+
+        elif eng.lower() == "jNeuroML_Brian2".lower():
+            from omv.engines.jneuromlbrian2 import JNeuroMLBrian2Engine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                ee.install(engine_version)
+
+        elif eng.lower() == "jNeuroML_NEURON".lower():
+            from omv.engines.jneuromlnrn import JNeuroMLNRNEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                ee.install(engine_version)
+
+        elif eng.lower() == "jNeuroML_EDEN".lower():
+            from omv.engines.jneuromleden import JNeuroMLEdenEngine as ee
+
+            if ee.is_installed():
+                already_installed = True
+            else:
+                ee.install(engine_version)
+
+        else:
+            inform(
+                "Code not implemented yet for installing %s using: omv install! Try running a test using this engine."
+                % eng
+            )
+            exit(1)
+        if already_installed:
+            inform("Engine %s was already installed" % eng)
+
+
+def set_env_vars():
+    if os.name == "nt":
+        # Windows does not have a HOME var defined by default
+        os.environ["HOME"] = os.environ["USERPROFILE"]
+
+
+if __name__ == "__main__":
+    main()