MasterMSM 2.0.1__py3-none-any.whl

mastermsm/test/download_data.py

@@ -0,0 +1,72 @@
+import os
+import unittest
+import urllib.request
+import urllib.error
+
+
+def _data_dir():
+    """Directory for the downloaded test trajectories.
+
+    In order of preference: $MASTERMSM_TEST_DATA, the ``data`` folder
+    next to this file (source checkouts and writable installs), or a
+    per-user cache (read-only installs, e.g. system or conda packages).
+    """
+    env = os.environ.get("MASTERMSM_TEST_DATA")
+    if env:
+        return env
+    here = os.path.join(os.path.dirname(__file__), "data")
+    if os.path.isdir(here) or os.access(os.path.dirname(here), os.W_OK):
+        return here
+    cache = os.environ.get("XDG_CACHE_HOME",
+                           os.path.join(os.path.expanduser("~"), ".cache"))
+    return os.path.join(cache, "mastermsm", "test-data")
+
+
+_DATA_DIR = _data_dir()
+
+
+def _download(url, dest, max_redirects=10):
+    """Download url to dest, following HTTP 308 (Python 3.10 urllib omits it).
+
+    Writes to a temporary file first so that an interrupted download
+    never leaves a truncated file at dest.
+    """
+    part = dest + ".part"
+    try:
+        for _ in range(max_redirects):
+            try:
+                urllib.request.urlretrieve(url, part)
+                os.replace(part, dest)
+                return
+            except urllib.error.HTTPError as e:
+                if e.code == 308 and e.headers.get("Location"):
+                    url = e.headers["Location"]
+                else:
+                    raise
+        raise urllib.error.URLError("too many redirects: %s" % url)
+    finally:
+        if os.path.exists(part):
+            os.remove(part)
+
+
+def _fetch(downloads):
+    """Download missing files; skip the calling test if that fails."""
+    try:
+        os.makedirs(_DATA_DIR, exist_ok=True)
+        for k, v in downloads.items():
+            dest = os.path.join(_DATA_DIR, k)
+            if not os.path.isfile(dest):
+                _download(v, dest)
+    except (urllib.error.URLError, OSError) as e:
+        raise unittest.SkipTest(
+            "test data could not be downloaded to %s (%s)" % (_DATA_DIR, e))
+
+
+def download_osf_alaTB():
+    _fetch({"alaTB.gro": "https://osf.io/hgbqs/download",
+            "alaTB.xtc": "https://osf.io/ujmhc/download"})
+
+
+def download_osf_ala5():
+    _fetch({"ala5.gro": "https://osf.io/6uznm/download",
+            "ala5.xtc": "https://osf.io/gmxpy/download"})

mastermsm/test/test_fewsm.py

@@ -0,0 +1,103 @@
+import unittest
+import mdtraj as md
+import numpy as np
+from mastermsm.trajectory import traj_lib, traj
+from mastermsm.msm import msm, msm_lib
+from mastermsm.fewsm import fewsm, fewsm_lib
+from mastermsm.test.download_data import download_osf_alaTB
+import os, pickle
+
+#class TestFewSM_Lib(unittest.TestCase):
+#    def setUp(self):
+#        pass
+#
+#    def test_sign(self):
+#        v = np.array([0] * 3)
+#        test = fewsm_lib.test_sign(v)
+#        self.assertEqual(test, False)
+#        v = np.array([-1, 0, 1])
+#        test = fewsm_lib.test_sign(v)
+#        self.assertEqual(test, True)
+#
+#    def test_metastability(self):
+#        T_test = np.random.rand(10,10)
+#        meta = fewsm_lib.metastability(T_test)
+#        self.assertIsInstance(meta, float)
+#        self.assertEqual(meta, np.sum(np.diag(T_test)))
+#
+#    def test_metropolis(self):
+#        delta = np.random.random()
+#        accept = fewsm_lib.metropolis(delta)
+#        self.assertIsInstance(accept, bool)
+#        delta = -1.
+#        accept = fewsm_lib.metropolis(delta)
+#        self.assertTrue(accept)
+#
+#    def test_beta(self):
+#        tests = [
+#            {
+#                "imc": 2,
+#                "mcsasteps": 10,
+#            },
+#            {
+#                "imc":1,
+#                "mcsasteps":1
+#            }
+#        ]
+#        for test in tests:
+#
+#            beta = fewsm_lib.beta(test["imc"], test["mcsasteps"])
+#            self.assertIsInstance(beta, float)
+#    def test_split_sign(self):
+#        macro = {}
+#        for i in range(10):
+#            macro[i] = [i * 10 + j for j in range(10)]
+#        lvec = np.random.rand(100)
+#
+#        new_macro, vals = fewsm_lib.split_sign(macro, lvec)
+#        self.assertIsInstance(new_macro, dict)
+#        self.assertGreaterEqual(len(new_macro.keys()), len(macro.keys()))
+#
+#    def test_split_sigma(self):
+#        macro = {}
+#        for i in range(10):
+#            macro[i] = [i * 10 + j for j in range(10)]
+#        lvec = np.random.rand(100)
+#
+#        new_macro, vals = fewsm_lib.split_sigma(macro, lvec)
+#        self.assertIsInstance(new_macro, dict)
+#        self.assertGreaterEqual(len(new_macro.keys()), len(macro.keys()))
+#
+#class TestFewSM(unittest.TestCase):
+#
+#    def setUp(self):
+#        download_test_data()
+#        self.tr = traj.TimeSeries(top='test/data/alaTB.gro', \
+#                                  traj=['test/data/protein_only.xtc'])
+#        self.tr.discretize('rama', states=['A', 'E'])
+#        self.tr.find_keys()
+#        self.msm = msm.SuperMSM([self.tr])
+#        self.msm.do_msm(10)
+#        self.msm.msms[10].do_trans()
+#
+#    def test_attributes(self):
+#        self.fewsm = fewsm.FEWSM(parent=self.msm.msms[10])
+#        self.assertIsNotNone(self.fewsm.macros)
+#        self.assertEqual(len(self.fewsm.macros), 2)
+#
+#    def test_map_trajectory(self):
+#        self.fewsm = fewsm.FEWSM(parent=self.msm.msms[10])
+#        self.fewsm.map_trajectory()
+#        self.mapped = self.fewsm.mappedtraj[0]
+#        self.assertIsNotNone(self.mapped)
+#        self.assertIsInstance(self.mapped, traj.TimeSeries)
+#        self.assertTrue(hasattr(self.mapped, 'dt'))
+#        self.assertTrue(hasattr(self.mapped, 'distraj'))
+#        self.assertEqual(len(set(self.mapped.distraj)), 2)
+#        self.assertEqual(sorted(set(self.mapped.distraj)), [0, 1])
+#
+#    def test_eigen_group(self):
+#        self.fewsm = fewsm.FEWSM(parent=self.msm.msms[10])
+#        macros = self.fewsm.eigen_group()
+#        print("MACROS! ", macros)
+#        self.assertIsInstance(macros, dict)