Adopt fx_ convention for cached fixtures

Author: jeromekelleher

tests/conftest.py

@@ -1,23 +1,24 @@
 import pathlib
 import shutil
 import gzip
+import tskit
 
 import pytest
 
 import sc2ts
 
 
 @pytest.fixture
-def data_cache():
+def fx_data_cache():
     cache_path = pathlib.Path("tests/data/cache")
     if not cache_path.exists():
         cache_path.mkdir()
     return cache_path
 
 
 @pytest.fixture
-def alignments_fasta(data_cache):
-    cache_path = data_cache / "alignments.fasta"
+def fx_alignments_fasta(fx_data_cache):
+    cache_path = fx_data_cache / "alignments.fasta"
     if not cache_path.exists():
         with gzip.open("tests/data/alignments.fasta.gz") as src:
             with open(cache_path, "wb") as dest:
@@ -26,18 +27,43 @@ def alignments_fasta(data_cache):
 
 
 @pytest.fixture
-def alignments_store(data_cache, alignments_fasta):
-    cache_path = data_cache / "alignments.db"
+def fx_alignment_store(fx_data_cache, fx_alignments_fasta):
+    cache_path = fx_data_cache / "alignments.db"
     if not cache_path.exists():
         with sc2ts.AlignmentStore(cache_path, "a") as a:
-            fasta = sc2ts.core.FastaReader(alignments_fasta)
+            fasta = sc2ts.core.FastaReader(fx_alignments_fasta)
             a.append(fasta, show_progress=False)
     return sc2ts.AlignmentStore(cache_path)
 
 @pytest.fixture
-def metadata_db(data_cache):
-    cache_path = data_cache / "metadata.db"
+def fx_metadata_db(fx_data_cache):
+    cache_path = fx_data_cache / "metadata.db"
     tsv_path = "tests/data/metadata.tsv"
     if not cache_path.exists():
         sc2ts.MetadataDb.import_csv(tsv_path, cache_path)
     return sc2ts.MetadataDb(cache_path)
+
+
+@pytest.fixture
+def fx_ts_2020_02_10(tmp_path, fx_data_cache, fx_metadata_db, fx_alignment_store):
+    target_date = "2020-02-10"
+    cache_path = fx_data_cache / f"{target_date}.ts"
+    if not cache_path.exists():
+        last_ts = sc2ts.initial_ts()
+        match_db = sc2ts.MatchDb.initialise(tmp_path / "match.db")
+        for date in fx_metadata_db.date_sample_counts():
+            print("INFERRING", date)
+            last_ts = sc2ts.extend(
+                alignment_store=fx_alignment_store,
+                metadata_db=fx_metadata_db,
+                base_ts=last_ts,
+                date=date,
+                match_db=match_db,
+                min_group_size=2,
+            )
+            if date == target_date:
+                break
+        last_ts.dump(cache_path)
+    return tskit.load(cache_path)
+
+

tests/test_alignments.py

@@ -7,27 +7,27 @@
 
 
 class TestAlignmentsStore:
-    def test_info(self, alignments_store):
-        assert "contains" in str(alignments_store)
+    def test_info(self, fx_alignment_store):
+        assert "contains" in str(fx_alignment_store)
 
-    def test_len(self, alignments_store):
-        assert len(alignments_store) == 55
+    def test_len(self, fx_alignment_store):
+        assert len(fx_alignment_store) == 55
 
-    def test_fetch_known(self, alignments_store):
-        a = alignments_store["SRR11772659"]
+    def test_fetch_known(self, fx_alignment_store):
+        a = fx_alignment_store["SRR11772659"]
         assert a.shape == (core.REFERENCE_SEQUENCE_LENGTH,)
         assert a[0] == "X"
         assert a[1] == "N"
         assert a[-1] == "N"
 
-    def test_keys(self, alignments_store):
-        keys = list(alignments_store.keys())
-        assert len(keys) == len(alignments_store)
+    def test_keys(self, fx_alignment_store):
+        keys = list(fx_alignment_store.keys())
+        assert len(keys) == len(fx_alignment_store)
         assert "SRR11772659" in keys
 
-    def test_in(self, alignments_store):
-        assert "SRR11772659" in alignments_store
-        assert "NOT_IN_STORE" not in alignments_store
+    def test_in(self, fx_alignment_store):
+        assert "SRR11772659" in fx_alignment_store
+        assert "NOT_IN_STORE" not in fx_alignment_store
 
 
 def test_get_gene_coordinates():
@@ -89,8 +89,8 @@ def test_error__examples(self, a):
         with pytest.raises(ValueError):
             sa.decode_alignment(np.array(a))
 
-    def test_encode_real(self, alignments_store):
-        h = alignments_store["SRR11772659"]
+    def test_encode_real(self, fx_alignment_store):
+        h = fx_alignment_store["SRR11772659"]
         a = sa.encode_alignment(h)
         assert a[0] == -1
         assert a[-1] == -1
@@ -145,8 +145,8 @@ def test_bad_window_size(self, w):
 
 
 class TestEncodeAndMask:
-    def test_known(self, alignments_store):
-        a = alignments_store["SRR11772659"]
+    def test_known(self, fx_alignment_store):
+        a = fx_alignment_store["SRR11772659"]
         ma = sa.encode_and_mask(a)
         assert ma.original_base_composition == {
             "T": 9566,

tests/test_cli.py

@@ -47,11 +47,11 @@ def test_additional_problematic_sites(self, tmp_path, additional):
 
 
 class TestListDates:
-    def test_defaults(self, metadata_db):
+    def test_defaults(self, fx_metadata_db):
         runner = ct.CliRunner(mix_stderr=False)
         result = runner.invoke(
             cli.cli,
-            f"list-dates {metadata_db.path}",
+            f"list-dates {fx_metadata_db.path}",
             catch_exceptions=False,
         )
         assert result.exit_code == 0
@@ -78,11 +78,11 @@ def test_defaults(self, metadata_db):
             "2020-02-13",
         ]
 
-    def test_counts(self, metadata_db):
+    def test_counts(self, fx_metadata_db):
         runner = ct.CliRunner(mix_stderr=False)
         result = runner.invoke(
             cli.cli,
-            f"list-dates {metadata_db.path} --counts",
+            f"list-dates {fx_metadata_db.path} --counts",
             catch_exceptions=False,
         )
         assert result.exit_code == 0

tests/test_inference.py

@@ -486,11 +486,10 @@ def test_high_recomb_mutation(self):
 
 
 class TestRealData:
-    # def test_first_day(self, tmp_path, alignments_store, metadata_db):
-    def test_first_day(self, tmp_path, alignments_store, metadata_db):
+    def test_first_day(self, tmp_path, fx_alignment_store, fx_metadata_db):
         ts = sc2ts.extend(
-            alignment_store=alignments_store,
-            metadata_db=metadata_db,
+            alignment_store=fx_alignment_store,
+            metadata_db=fx_metadata_db,
             base_ts=sc2ts.initial_ts(),
             date="2020-01-19",
             match_db=sc2ts.MatchDb.initialise(tmp_path / "match.db"),
@@ -536,3 +535,32 @@ def test_first_day(self, tmp_path, alignments_store, metadata_db):
             },
             "original_md5": "e96feaa72c4f4baba73c2e147ede7502",
         }
+
+    def test_2020_02_10_metadata(self, fx_ts_2020_02_10):
+        ts = fx_ts_2020_02_10
+        assert ts.metadata["sc2ts"]["date"] == "2020-02-10"
+        samples_strain = [ts.node(u).metadata["strain"] for u in ts.samples()]
+        assert ts.metadata["sc2ts"]["samples_strain"] == samples_strain
+        # print(ts.tables.mutations)
+        # print(ts.draw_text())
+
+
+class TestMatchingDetails:
+
+    def test_exact_matches(self, fx_ts_2020_02_10, fx_alignment_store, fx_metadata_db):
+        print("HERE")
+
+    def test_other_exact_matches(self, tmp_path, fx_ts_2020_02_10, fx_alignment_store, fx_metadata_db):
+        print("HERE")
+        match_db = sc2ts.MatchDb.initialise(tmp_path / "match.db")
+        ts = sc2ts.extend(
+            alignment_store=fx_alignment_store,
+            metadata_db=fx_metadata_db,
+            base_ts=fx_ts_2020_02_10,
+            date="2020-02-11",
+            match_db=match_db,
+            min_group_size=2,
+        )
+
+
+

tests/test_metadata.py

@@ -3,73 +3,39 @@
 
 
 class TestMetadataDb:
-    def test_known(self, metadata_db):
-        record = metadata_db["SRR11772659"]
+    def test_known(self, fx_metadata_db):
+        record = fx_metadata_db["SRR11772659"]
         assert record["strain"] == "SRR11772659"
         assert record["date"] == "2020-01-19"
         assert record["Viridian_pangolin"] == "A"
 
-    def test_missing_sequence(self, metadata_db):
+    def test_missing_sequence(self, fx_metadata_db):
         # We include sequence that's not in the alignments DB
-        assert "ERR_MISSING" in metadata_db
+        assert "ERR_MISSING" in fx_metadata_db
 
-    def test_keys(self, metadata_db):
-        keys = list(metadata_db.keys())
+    def test_keys(self, fx_metadata_db):
+        keys = list(fx_metadata_db.keys())
         assert "SRR11772659" in keys
         assert len(set(keys)) == len(keys)
         df = pd.read_csv("tests/data/metadata.tsv", sep="\t")
         assert set(keys) == set(df["strain"])
 
-    def test_in(self, metadata_db):
-        assert "SRR11772659" in metadata_db
-        assert "DEFO_NOT_IN_DB" not in metadata_db
+    def test_in(self, fx_metadata_db):
+        assert "SRR11772659" in fx_metadata_db
+        assert "DEFO_NOT_IN_DB" not in fx_metadata_db
 
-    def test_get_all_days(self, metadata_db):
-        results = metadata_db.get_days()
-        assert results == [
-            "2020-01-01",
-            "2020-01-19",
-            "2020-01-24",
-            "2020-01-25",
-            "2020-01-28",
-            "2020-01-29",
-            "2020-01-30",
-            "2020-01-31",
-            "2020-02-01",
-            "2020-02-02",
-            "2020-02-03",
-            "2020-02-04",
-            "2020-02-05",
-            "2020-02-06",
-            "2020-02-07",
-            "2020-02-08",
-            "2020-02-09",
-            "2020-02-10",
-            "2020-02-11",
-            "2020-02-13",
-        ]
+    # TODO test count_days. See test_cli.
 
-    def test_get_days_greater(self, metadata_db):
-        results = metadata_db.get_days("2020-02-06")
-        assert results == [
-            "2020-02-07",
-            "2020-02-08",
-            "2020-02-09",
-            "2020-02-10",
-            "2020-02-11",
-            "2020-02-13",
-        ]
+    def test_get_days_none(self, fx_metadata_db):
+        assert fx_metadata_db.get_days("2022-02-06") == []
 
-    def test_get_days_none(self, metadata_db):
-        assert metadata_db.get_days("2022-02-06") == []
-
-    def test_get_first(self, metadata_db):
-        results = list(metadata_db.get("2020-01-01"))
+    def test_get_first(self, fx_metadata_db):
+        results = list(fx_metadata_db.get("2020-01-01"))
         assert len(results) == 1
-        assert results[0] == metadata_db["SRR14631544"]
+        assert results[0] == fx_metadata_db["SRR14631544"]
 
-    def test_get_multi(self, metadata_db):
-        results = list(metadata_db.get("2020-02-11"))
+    def test_get_multi(self, fx_metadata_db):
+        results = list(fx_metadata_db.get("2020-02-11"))
         assert len(results) == 2
         for result in results:
             assert result["date"] == "2020-02-11"