OSBModelValidation 0.2.18__py3-none-any.whl

omv/parse_omt.py

@@ -0,0 +1,118 @@
+from omv.engines import OMVEngines
+from omv.engines.engine import EngineInstallationError, EngineExecutionError
+from omv.omt_mep_parser import OMVTestParser
+from omv.common.inout import inform, check, trim_path
+from omv.tally import Tallyman
+import sys
+import platform
+
+
+def parse_omt(omt_path, do_not_run=False, engine_version=None, ignore_non_py3=False):
+    inform("")
+    action = "Running"
+    if do_not_run:
+        action = "Checking"
+    inform(
+        action + " the tests defined in ",
+        trim_path(omt_path),
+        underline="=",
+        center=False,
+    )
+
+    mepomt = OMVTestParser(omt_path)
+    if not mepomt.engine in OMVEngines:
+        inform(
+            "Error! Unrecognised engine: %s (try running: omv list-engines)"
+            % mepomt.engine
+        )
+        exit(1)
+    engine = OMVEngines[mepomt.engine](
+        mepomt.modelpath, do_not_check_install=do_not_run, engine_version=engine_version
+    )
+
+    experiments = [exp for exp in mepomt.generate_exps(engine)]
+
+    tally = Tallyman(mepomt)
+
+    inform(
+        "Found %i experiment(s) to run on engine: %s "
+        % (len(experiments), engine.name),
+        indent=1,
+    )
+    # print('%s, %s, %s'%(platform.python_version_tuple()[0],ignore_non_py3,engine.python3_compatible))
+
+    if (
+        platform.python_version_tuple()[0] == "3"
+        and ignore_non_py3
+        and not engine.python3_compatible
+    ):
+        inform(
+            "Not running experiment(s) on: %s, as this is Python %s and engine is not Python 3 compatible..."
+            % (engine.name, platform.python_version()),
+            indent=1,
+        )
+        tally.report_passing_if_no_exps = True
+
+    elif not do_not_run:
+        try:
+            engine.run()
+            some_failed = False
+            for exp in experiments:
+                inform("Running checks for experiment: ", exp.name, indent=1)
+                inform("")
+                results = exp.check_all()
+                inform(
+                    "{:<30}{:^20}".format("Observable", "Test Passed"),
+                    underline="-",
+                    indent=3,
+                )
+                for rn, rv in results.items():
+                    if sys.version_info >= (3, 0):
+                        inform("{:<30}{:^20}".format(rn, check(rv)), indent=3)
+                    else:
+                        inform("{:<30}{:^20}".format(rn, check(rv)), indent=3)
+                    if not rv:
+                        some_failed = True
+                tally.add_experiment(exp, results)
+
+            if some_failed:
+                inform("+++++++++++++++++++++ Error info ++++++++++++++++++", indent=3)
+                inform(" Return code: %s" % engine.returncode, indent=3)
+                if hasattr(engine, "stdout"):
+                    if isinstance(engine.stdout, str):
+                        out = engine.stdout
+                    else:
+                        out = str(engine.stdout.decode())
+                    inform(
+                        " Output: %s"
+                        % out.replace(
+                            "\n", "\n[omv] %s:%s > " % (mepomt.omt_path, exp.name)
+                        ),
+                        indent=3,
+                    )
+                inform("+++++++++++++++++++++++++++++++++++++++++++++++++++", indent=3)
+
+        except (EngineInstallationError, EngineExecutionError):
+            # TODO: serialize exception info
+            inform(
+                "ERROR running engine ",
+                engine.name,
+                indent=1,
+                underline="-",
+                overline="-",
+            )
+            inform("+++++++++++++++++++++ Error info ++++++++++++++++++", indent=3)
+            inform(" Return code: %s" % engine.returncode, indent=3)
+            if hasattr(engine, "stdout"):
+                if isinstance(engine.stdout, str):
+                    out = engine.stdout
+                else:
+                    out = str(engine.stdout.decode())
+                inform(
+                    " Output: %s"
+                    % out.replace("\n", "\n[omv] %s > " % (mepomt.omt_path)),
+                    indent=3,
+                )
+            inform("+++++++++++++++++++++++++++++++++++++++++++++++++++", indent=3)
+
+    return tally

omv/tally.py

@@ -0,0 +1,112 @@
+from collections import OrderedDict
+from omv.common.inout import trim_path
+
+
+class Tallyman(object):
+    def __init__(self, mepomt):
+        self.omt = mepomt.omt_path
+        self.mep = mepomt.mep_path
+        self.engine = mepomt.engine
+        self.modelpath = mepomt.modelpath
+        self.experiments = {}
+        self.report_passing_if_no_exps = False
+
+    def all_passed(self):
+        alltrue = True if any(self.experiments) else self.report_passing_if_no_exps
+        for res in self.experiments.values():
+            alltrue = alltrue and all(res.values())
+        return alltrue
+
+    def add_experiment(self, exp, results):
+        self.experiments[exp.name] = results
+
+    def __lt__(self, other):
+        if other.mep == None:
+            return True
+        return self.omt < other.omt
+
+    def serialize(self):
+        s = OrderedDict({"engine": self.engine})
+        s["MEP file"] = self.mep
+        s["OMT file"] = self.omt
+        s["Model path"] = self.modelpath
+        s["Experiments"] = self.experiments
+        s["All Passed"] = self.all_passed()
+        # return dump(s, default_flow_style=False)
+        return s
+
+    def __repr__(self):
+        return str(self.serialize())
+
+
+class TallyHolder(object):
+    tallies = {}
+    all_engines = []
+
+    def add(self, tally):
+        if not tally.engine in self.all_engines:
+            self.all_engines.append(tally.engine)
+
+        mp = trim_path(tally.modelpath)
+
+        if not mp in self.tallies:
+            self.tallies[mp] = {}
+
+        mptallies = self.tallies[mp]
+
+        if not tally.engine in mptallies:
+            mptallies[tally.engine] = []
+
+        mptallies[tally.engine].append(tally)
+
+    def summary(self):
+        width1 = 60
+        border = "+" + "-" * width1 + "+"
+        header = "|" + " " * width1 + "| "
+
+        totals = {}
+        for engine in self.all_engines:
+            border += "-" * (len(engine) + 2) + "+"
+            header += engine + " | "
+            totals[engine] = 0
+
+        summary = "%s\n%s\n%s\n" % (border, header, border)
+
+        for mp in self.tallies.keys():
+            mp_ = mp
+            max = width1 - 2
+            if len(mp_) > max:
+                pre = 8
+                mp_ = "%s(...)%s" % (mp_[:pre], mp_[-1 * (max - pre - 6) :])
+
+            summary += "| " + mp_ + " " * (width1 - len(mp_) - 2) + " |   "
+
+            mptallies = self.tallies[mp]
+
+            for engine in self.all_engines:
+                if not engine in mptallies:
+                    info = "%s" % (" ")
+                    summary += " " * (len(engine) - len(info) - 2) + info + " |   "
+                else:
+                    tals = mptallies[engine]
+                    for t in tals:
+                        if t.engine == engine:
+                            info = "%s" % (len(t.experiments))
+                            if not t.mep:
+                                info += "d"
+                            if not t.all_passed():
+                                info += "X"
+                            totals[engine] += len(t.experiments)
+                            summary += (
+                                " " * (len(engine) - len(info) - 2) + info + " |   "
+                            )
+            summary += "\n"
+
+        summary += border + "\n" + "| Totals: " + " " * (width1 - 9) + "|   "
+
+        for engine in self.all_engines:
+            info = "%s" % (totals[engine])
+            summary += " " * (len(engine) - len(info) - 2) + info + " |   "
+
+        summary += "\n" + border
+        return summary

omv/test/test_rates.py

@@ -0,0 +1,38 @@
+from omv.common.inout import set_verbosity
+
+from omv.analyzers.utils.timeseries import *
+
+
+def test_rates():
+    set_verbosity(2)
+
+    tsNone = []
+    tsA = [0.1]
+    tsB = [0.1, 0.2]
+
+    ts1 = [0.1, 0.2, 0.3, 0.40]
+    ts2 = [0.1, 0.3, 0.50]
+
+    methods = [ISI_BASED_SPIKERATE_CALC, DURATION_BASED_SPIKERATE_CALC]
+
+    for method in methods:
+        opts = [tsNone, tsA, tsB, ts1, ts2, {"0": ts1}, {"0": ts1, "1": ts2}]
+        exp = {}
+        exp[ISI_BASED_SPIKERATE_CALC] = [0, 0, 10, 10, 0, 10, 5]
+        exp[DURATION_BASED_SPIKERATE_CALC] = [0, 4, 8, 8, 4, 8, 6]
+
+        for i in range(len(opts)):
+            opt = opts[i]
+            start_time = 0
+            end_time = 0.25
+            r = get_spike_rate(opt, method, start_time, end_time)
+            inform(
+                " > Rate in %s->%s (%s) for %s: %s\n"
+                % (start_time, end_time, method, opt, r),
+                indent=2,
+            )
+            assert r == exp[method][i]
+
+
+if __name__ == "__main__":
+    test_rates()

omv/test/test_types.py

@@ -0,0 +1,29 @@
+import glob
+from os.path import splitext, basename, normpath
+
+
+def _walk_testdir(root, validator):
+    for f in glob.glob(root + "/test/*.yaml"):
+        print("found test document", f)
+        fname = splitext(basename(f))[0]
+        try:
+            target = fname[: fname.rindex(".")]
+        except ValueError:
+            target = fname
+
+        schema_src = normpath("".join([root, "/", target, ".yaml"]))
+        print("using schema", schema_src)
+        assert validator.validate(schema_src, f)
+        print("valid!\n")
+
+
+def test_base():
+    from ..validation.rx_validator import RXSchemaValidator as v
+
+    _walk_testdir("../schemata/types/base", v())
+
+
+def test_derived():
+    from ..validation.validate import OMVValidator as o
+
+    _walk_testdir("../schemata/types", o())

omv/validation/rx_validator.py

@@ -0,0 +1,35 @@
+import pyrx
+import yaml
+
+
+class RXSchemaValidator(object):
+    def __init__(self):
+        self.rx = pyrx.Factory({"register_core_types": True})
+
+    def generate_schema(self, schema_src):
+        schema = self.parse_yaml_file(schema_src)
+        print("generating schema from %s" % schema)
+        return self.rx.make_schema(schema)
+
+    def parse_yaml_file(self, fname):
+        with open(fname) as f:
+            y = yaml.safe_load(f)
+        return y
+
+    def validate(self, schema_src, doc_src):
+        doc = self.parse_yaml_file(doc_src)
+        print("validating document %s" % doc)
+        return self.generate_schema(schema_src).check(doc)
+
+
+if __name__ == "__main__":
+    import sys
+
+    try:
+        schema_src, doc_src = sys.argv[1:]
+    except:
+        print("usage: validate_rx.py schema.yaml document.yaml")
+        sys.exit(1)
+
+    s = RXSchemaValidator()
+    print(s.validate(schema_src, doc_src))

omv/validation/utils.py

@@ -0,0 +1,51 @@
+def topological_sort(source):
+    """perform topo sort on elements.
+
+    :arg source: list of ``(name, [list of dependancies])`` pairs
+    :returns: list of names, with dependancies listed first
+    """
+    pending = [
+        (name, set(deps)) for name, deps in source
+    ]  # copy deps so we can modify set in-place
+    emitted = []
+    while pending:
+        next_pending = []
+        next_emitted = []
+        for entry in pending:
+            name, deps = entry
+            deps.difference_update(emitted)  # remove deps we emitted last pass
+            if deps:  # still has deps? recheck during next pass
+                next_pending.append(entry)
+            else:  # no more deps? time to emit
+                yield name
+                emitted.append(
+                    name
+                )  # <-- not required, but helps preserve original ordering
+                next_emitted.append(
+                    name
+                )  # remember what we emitted for difference_update() in next pass
+        if (
+            not next_emitted
+        ):  # all entries have unmet deps, one of two things is wrong...
+            raise ValueError(
+                "cyclic or missing dependancy detected: %r" % (next_pending,)
+            )
+        pending = next_pending
+        emitted = next_emitted
+
+
+def all_types_in_schema(d):
+    for k, v in d.items():
+        if isinstance(v, dict):
+            for x in all_types_in_schema(v):
+                yield x
+        elif isinstance(v, list):
+            for el in v:
+                for x in all_types_in_schema(el):
+                    yield x
+        else:
+            try:
+                if v.startswith("/omv"):
+                    yield v
+            except AttributeError:
+                pass

omv/validation/validate.py

@@ -0,0 +1,53 @@
+from os.path import splitext, basename
+from omv.validation.rx_validator import RXSchemaValidator
+from omv.validation.utils import topological_sort, all_types_in_schema
+from pkg_resources import resource_filename
+
+
+class OMVValidator(RXSchemaValidator):
+    def __init__(self):
+        super(OMVValidator, self).__init__()
+        self.add_osb_prefix()
+        self.register_osb_types()
+
+    def add_osb_prefix(self):
+        self.prefix = "tag:opensourcebrain.org,2014:schemata/omv/"
+        self.rx.add_prefix("omv", self.prefix)
+
+    def register_osb_types(self):
+        self.omv_types = {}
+        from glob import glob
+
+        typedir = resource_filename("omv", "schemata/types/")
+        for omv in glob(typedir + "*.yaml") + glob(typedir + "/base/*.yaml"):
+            tag = self.prefix + splitext(basename(omv))[0]
+            print("registering", tag)
+            self.omv_types[tag] = self.parse_yaml_file(omv)
+
+        for tag in self.sort_types_by_dependencies(self.omv_types):
+            schema = self.omv_types[tag]
+            print("learning", tag)
+            print("with schema", schema)
+            self.rx.learn_type(tag, schema)
+
+    def sort_types_by_dependencies(self, tag_schema_map):
+        alldeps = []
+        for tag, schema in tag_schema_map.items():
+            depset = set([self.prefix + v[5:] for v in all_types_in_schema(schema)])
+            alldeps.append((tag, depset))
+
+        return topological_sort(alldeps)
+
+
+if __name__ == "__main__":
+    import sys
+
+    try:
+        schema_src, doc_src = sys.argv[1:]
+    except:
+        print("usage: validate.py schema.yaml document.yaml")
+        sys.exit(1)
+
+    s = OMVValidator()
+    # print('validating document againt schema'
+    print(s.validate(schema_src, doc_src))

omv/validation/validate_mep.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+import sys
+from omv.validation.validate import OMVValidator
+from pkg_resources import resource_filename
+
+
+def validate(mep_src):
+    s = OMVValidator()
+    print("Validating document againt mep schema: ")
+    schema = resource_filename("omv", "schemata/mep.yaml")
+    print(s.validate(schema, mep_src))
+
+
+if __name__ == "__main__":
+    validate(sys.argv[1])