loqusdb 2.7.10__py3-none-any.whl → 2.7.12__py3-none-any.whl

tests/plugins/mongo/test_case_operations.py

@@ -1,143 +0,0 @@
-import pytest
-
-from loqusdb.exceptions import CaseError
-
-
-class TestDeleteCase:
-    def test_delete_one_case(self, mongo_adapter, case_obj):
-        """Test to delete one case"""
-
-        db = mongo_adapter.db
-
-        mongo_case = db.case.find_one()
-
-        assert mongo_case == None
-
-        db.case.insert_one(case_obj)
-
-        mongo_case = db.case.find_one()
-
-        assert mongo_case["case_id"] == case_obj["case_id"]
-        assert mongo_case["vcf_path"] == case_obj["vcf_path"]
-
-        mongo_adapter.delete_case(case_obj)
-
-        assert db.case.find_one() == None
-
-    def test_delete_non_existing(self, mongo_adapter, case_obj):
-        """Test to delete non exsting case"""
-
-        with pytest.raises(CaseError):
-            mongo_adapter.delete_case(case_obj)
-
-
-class TestInsertCase:
-    def test_insert_one_case(self, mongo_adapter, case_obj):
-        db = mongo_adapter.db
-
-        mongo_adapter.add_case(case_obj)
-
-        mongo_case = db.case.find_one()
-
-        assert mongo_case["case_id"] == case_obj["case_id"]
-        assert mongo_case["vcf_path"] == case_obj["vcf_path"]
-
-    def test_insert_one_case_twice(self, mongo_adapter, case_obj):
-        db = mongo_adapter.db
-
-        mongo_adapter.add_case(case_obj)
-
-        with pytest.raises(CaseError):
-            mongo_adapter.add_case(case_obj)
-
-
-class TestGetCase:
-    def test_get_case(self, mongo_adapter, case_obj):
-        """Test to get non existing case"""
-
-        db = mongo_adapter.db
-        db.case.insert_one(case_obj)
-
-        mongo_case = mongo_adapter.case(case_obj)
-
-        assert mongo_case["case_id"] == case_obj["case_id"]
-        assert mongo_case["vcf_path"] == case_obj["vcf_path"]
-
-    def test_get_non_existing(self, mongo_adapter, simple_case):
-        """Test to get non existing case"""
-
-        db = mongo_adapter.db
-
-        mongo_case = mongo_adapter.case(simple_case)
-
-        assert mongo_case == None
-
-    def test_get_multiple_cases(self, mongo_adapter):
-        """Test to get non existing case"""
-
-        db = mongo_adapter.db
-        case_1 = {"case_id": "test", "vcf_path": "test.vcf"}
-
-        case_2 = {"case_id": "test2", "vcf_path": "test2.vcf"}
-
-        db.case.insert_one(case_1)
-        db.case.insert_one(case_2)
-
-        mongo_cases = mongo_adapter.cases()
-
-        assert sum(1 for i in mongo_cases) == 2
-
-    def test_nr_cases(self, mongo_adapter):
-        """Test to get non existing case"""
-
-        db = mongo_adapter.db
-        case_1 = {"case_id": "test", "vcf_path": "test.vcf", "vcf_sv_path": None}
-
-        db.case.insert_one(case_1)
-
-        assert mongo_adapter.nr_cases() == 1
-        assert mongo_adapter.nr_cases(sv_cases=True) == 0
-        assert mongo_adapter.nr_cases(snv_cases=True) == 1
-        assert mongo_adapter.nr_cases(snv_cases=True, sv_cases=True) == 1
-
-    def test_nr_cases_only_snv(self, mongo_adapter):
-        """Test to get non existing case"""
-        db = mongo_adapter.db
-        case_1 = {"case_id": "test", "vcf_path": "test.vcf"}
-
-        db.case.insert_one(case_1)
-
-        assert mongo_adapter.nr_cases() == 1
-        assert mongo_adapter.nr_cases(sv_cases=True) == 0
-        assert mongo_adapter.nr_cases(snv_cases=True) == 1
-
-    def test_nr_cases_sv(self, mongo_adapter):
-        """Test to get non existing case"""
-
-        db = mongo_adapter.db
-        case_1 = {"case_id": "test", "vcf_sv_path": "test.vcf"}
-
-        db.case.insert_one(case_1)
-
-        assert mongo_adapter.nr_cases() == 1
-        assert mongo_adapter.nr_cases(sv_cases=True) == 1
-        assert mongo_adapter.nr_cases(snv_cases=True) == 0
-
-    def test_get_multiple_cases(self, mongo_adapter):
-        """Test to get non existing case"""
-
-        db = mongo_adapter.db
-        case_1 = {"case_id": "test", "vcf_path": "test.vcf", "vcf_sv_path": "test.vcf"}
-
-        case_2 = {"case_id": "test2", "vcf_path": "test2.vcf"}
-
-        case_3 = {"case_id": "test3", "vcf_path": "test3.vcf"}
-
-        db.case.insert_one(case_1)
-        db.case.insert_one(case_2)
-        db.case.insert_one(case_3)
-
-        assert mongo_adapter.nr_cases() == 3
-        assert mongo_adapter.nr_cases(snv_cases=True) == 3
-        assert mongo_adapter.nr_cases(sv_cases=True) == 1
-        assert mongo_adapter.nr_cases(sv_cases=True, snv_cases=True) == 3

tests/plugins/mongo/test_connect.py

@@ -1,8 +0,0 @@
-from loqusdb.plugins.mongo.adapter import MongoAdapter
-
-
-def test_connect(mongo_client):
-    db_name = "test"
-    adapter = MongoAdapter(mongo_client, db_name)
-
-    assert adapter.db_name == db_name

tests/plugins/mongo/test_flask_extension.py

@@ -1,27 +0,0 @@
-from mongomock import MongoClient
-
-from loqusdb.plugins.mongo.adapter import MongoAdapter
-
-
-class MockFlaskApp(object):
-    """Mock a Flask App"""
-
-    def __init__(self, host="localhost", port=27017, db_name="test"):
-        client = MongoClient()
-
-        self.config = {}
-        self.extensions = {"pymongo": {}}
-
-        self.config["MONGO_DBNAME"] = db_name
-        self.config["MONGO_PORT"] = port
-        self.config["MONGO_HOST"] = host
-
-        # This is how flaskpymongo sets it up:
-        self.extensions["pymongo"]["MONGO"] = [client, client[db_name]]
-
-
-def test_init_app(mongo_client):
-    app = MockFlaskApp()
-    adapter = MongoAdapter()
-    adapter.init_app(app)
-    assert adapter.db_name == app.config["MONGO_DBNAME"]

tests/plugins/mongo/test_get_sv.py

@@ -1,27 +0,0 @@
-from loqusdb.build_models.variant import build_variant
-
-
-def test_get_insertion(small_insert_variant, mongo_adapter, case_obj):
-    adapter = mongo_adapter
-    ## GIVEN a mongo adapter with a small insertion
-    variant = small_insert_variant
-    case_id = case_obj["case_id"]
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    adapter.add_case(case_obj)
-    adapter.add_structural_variant(formated_variant)
-    for variant_obj in adapter.db.structural_variant.find():
-        assert variant_obj
-
-
-def test_get_translocation(translocation_variant, mongo_adapter, case_obj):
-    adapter = mongo_adapter
-    ## GIVEN a mongo adapter with a translocation
-    variant = translocation_variant
-    case_id = case_obj["case_id"]
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    adapter.add_case(case_obj)
-    adapter.add_structural_variant(formated_variant)
-    for variant_obj in adapter.db.structural_variant.find():
-        assert variant_obj

tests/plugins/mongo/test_load_svs.py

@@ -1,74 +0,0 @@
-from loqusdb.build_models.variant import build_variant
-
-
-def test_load_insertion(small_insert_variant, mongo_adapter, case_obj):
-    adapter = mongo_adapter
-    ## GIVEN a mongo adapter with a case
-    variant = small_insert_variant
-    case_id = case_obj["case_id"]
-    adapter.add_case(case_obj)
-
-    ## WHEN loading a small insertion
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-    adapter.add_structural_variant(formated_variant)
-
-    ## THEN assert the object returned is correct
-    variant_cluster = adapter.db.structural_variant.find_one()
-
-    assert variant_cluster["families"] == [case_id]
-
-
-def test_load_same_insertion_twice(small_insert_variant, mongo_adapter, case_obj):
-    adapter = mongo_adapter
-    ## GIVEN a mongo adapter with a case
-    variant = small_insert_variant
-    case_id = case_obj["case_id"]
-    adapter.add_case(case_obj)
-
-    ## WHEN loading a small insertion
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-    adapter.add_structural_variant(formated_variant)
-    formated_variant["case_id"] = "2"
-    adapter.add_structural_variant(formated_variant)
-
-    ## THEN assert the object returned is correct
-    variant_cluster = adapter.db.structural_variant.find_one()
-
-    assert set(variant_cluster["families"]) == set([case_id, "2"])
-
-
-def test_load_translocation(translocation_variant, case_obj, mongo_adapter):
-    adapter = mongo_adapter
-    ## GIVEN a mongo adapter with a case
-    variant = translocation_variant
-    case_id = case_obj["case_id"]
-    adapter.add_case(case_obj)
-
-    ## WHEN loading a small insertion
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-    adapter.add_structural_variant(formated_variant)
-
-    ## THEN assert the object returned is correct
-    variant_cluster = adapter.db.structural_variant.find_one()
-
-    assert variant_cluster["families"] == [case_id]
-
-
-def test_load_same_translocation_twice(translocation_variant, case_obj, mongo_adapter):
-    adapter = mongo_adapter
-    ## GIVEN a mongo adapter with a case
-    variant = translocation_variant
-    case_id = case_obj["case_id"]
-    adapter.add_case(case_obj)
-
-    ## WHEN loading a small insertion
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-    adapter.add_structural_variant(formated_variant)
-
-    formated_variant["case_id"] = "2"
-    adapter.add_structural_variant(formated_variant)
-
-    ## THEN assert the object returned is correct
-    variant_cluster = adapter.db.structural_variant.find_one()
-
-    assert set(variant_cluster["families"]) == set([case_id, "2"])

tests/plugins/mongo/test_variant_operations.py

@@ -1,278 +0,0 @@
-import copy
-
-from loqusdb.build_models.variant import build_variant
-
-
-class TestInsertVariant:
-    def test_insert_one_variant(self, mongo_adapter, simplest_variant):
-        """Test to insert one variant"""
-
-        mongo_adapter.add_variant(simplest_variant)
-
-        db = mongo_adapter.db
-
-        # Get the variant without the adapter
-        mongo_variant = db.variant.find_one()
-
-        assert mongo_variant["_id"] == "test"
-        assert mongo_variant["observations"] == 1
-        assert mongo_variant["homozygote"] == 0
-
-    def test_insert_one_variant_twice(self, mongo_adapter, simplest_variant):
-        """Test to insert one variant"""
-
-        mongo_adapter.add_variant(simplest_variant)
-        mongo_adapter.add_variant(simplest_variant)
-
-        db = mongo_adapter.db
-
-        mongo_variant = db.variant.find_one()
-
-        assert mongo_variant["_id"] == "test"
-        assert mongo_variant["observations"] == 2
-        assert mongo_variant.get("homozygote", 0) == 0
-
-    def test_insert_hom_variant(self, real_mongo_adapter, homozygous_variant):
-        """Test to insert a homozygote variant"""
-        mongo_adapter = real_mongo_adapter
-        mongo_adapter.add_variant(homozygous_variant)
-
-        db = mongo_adapter.db
-
-        mongo_variant = db.variant.find_one()
-        assert mongo_variant["_id"] == "test"
-        assert mongo_variant["observations"] == 1
-        assert mongo_variant.get("homozygote", 0) == 1
-        assert mongo_variant["families"] == ["1"]
-
-    def test_insert_many(self, mongo_adapter, simplest_variant):
-        """Test to insert a homozygote variant"""
-
-        for _ in range(10000):
-            mongo_adapter.add_variant(simplest_variant)
-
-        db = mongo_adapter.db
-
-        mongo_variant = db.variant.find_one()
-        assert mongo_variant["_id"] == "test"
-        assert mongo_variant["observations"] == 10000
-        assert mongo_variant.get("homozygote", 0) == 0
-
-
-class TestGetVariant:
-    def test_get_variant(self, mongo_client, mongo_adapter, simplest_variant):
-        """Test to insert one variant"""
-
-        # Insert without adapter
-        db = mongo_client["test"]
-        db.variant.insert_one(simplest_variant)
-
-        mongo_variant = mongo_adapter.get_variant(simplest_variant)
-        assert mongo_variant["_id"] == "test"
-
-    def test_get_none(self, mongo_adapter, simplest_variant):
-        """Test to get non existing variant"""
-
-        mongo_variant = mongo_adapter.get_variant(simplest_variant)
-
-        assert mongo_variant is None
-
-
-class TestBulkOperations:
-    def test_insert_one_variant(self, real_mongo_adapter, simplest_variant):
-        """Test to insert one variant with bulk insert"""
-
-        mongo_adapter = real_mongo_adapter
-        variants = [simplest_variant]
-
-        mongo_adapter.add_variants(variants)
-        db = mongo_adapter.db
-        mongo_variant = db.variant.find_one()
-
-        assert mongo_variant["_id"] == "test"
-        assert mongo_variant["observations"] == 1
-        assert mongo_variant["homozygote"] == 0
-
-    def test_insert_two_variants(self, real_mongo_adapter):
-        """Test to insert two variants with bulk"""
-
-        adapter = real_mongo_adapter
-        db = adapter.db
-
-        variants = [
-            {"_id": "test", "homozygote": 0},
-            {"_id": "test_1", "homozygote": 1},
-        ]
-
-        adapter.add_variants(variants)
-
-        first_variant = db.variant.find_one({"_id": "test"})
-        second_variant = db.variant.find_one({"_id": "test_1"})
-
-        assert first_variant["_id"] == "test"
-        assert first_variant["observations"] == 1
-        assert first_variant.get("homozygote", 0) == 0
-
-        assert second_variant["_id"] == "test_1"
-        assert second_variant["observations"] == 1
-        assert second_variant.get("homozygote", 0) == 1
-
-    def test_insert_many(self, real_mongo_adapter):
-        adapter = real_mongo_adapter
-        db = adapter.db
-
-        variants = ({"_id": "test", "homozygote": 0} for i in range(20000))
-
-        adapter.add_variants(variants)
-
-        mongo_variant = db.variant.find_one()
-
-        assert mongo_variant["_id"] == "test"
-        assert mongo_variant["observations"] == 20000
-        assert mongo_variant.get("homozygote", 0) == 0
-
-
-class TestRemoveVariant:
-    def test_remove_one_variant(self, mongo_adapter):
-        """Test to update one variant"""
-
-        db = mongo_adapter.db
-
-        variant = {"_id": "test", "observations": 1}
-
-        db.variant.insert_one(variant)
-
-        mongo_adapter.delete_variant(variant)
-
-        assert db.variant.find_one() is None
-
-    def test_downcount_one_variant(self, mongo_adapter):
-        """Test to update one variant"""
-
-        db = mongo_adapter.db
-
-        insert_variant = {"_id": "test", "families": ["1", "2"], "observations": 2}
-
-        db.variant.insert_one(insert_variant)
-
-        variant = {"_id": "test", "case_id": "1"}
-
-        mongo_adapter.delete_variant(variant)
-
-        mongo_variant = db.variant.find_one()
-
-        assert mongo_variant["observations"] == 1
-        assert mongo_variant["families"] == ["2"]
-
-    def test_remove_non_existing(self, mongo_adapter, simplest_variant):
-        db = mongo_adapter.db
-
-        mongo_adapter.delete_variant(simplest_variant)
-
-        assert db.variant.find_one() is None
-
-
-class TestRemoveSV:
-    def test_remove_one_SV(self, mongo_adapter, del_variant, case_obj):
-        # GIVEN a database poulated with one SV
-        db = mongo_adapter.db
-        formated_variant = build_variant(
-            del_variant, case_obj=case_obj, case_id=case_obj["case_id"]
-        )
-        mongo_adapter.add_structural_variant(formated_variant)
-        mongo_SV = db.structural_variant.find_one()
-        mongo_identity = db.identity.find_one()
-        assert mongo_SV is not None
-        assert mongo_identity is not None
-        # WHEN deleting SV
-        mongo_adapter.delete_structural_variant(formated_variant)
-
-        # THEN there should be no remaining SVs in the database
-        mongo_SV = db.structural_variant.find_one()
-        mongo_identity = db.indentity.find_one()
-        assert mongo_SV is None
-        assert mongo_identity is None
-
-    def test_remove_one_of_two_SV(self, mongo_adapter, duptandem_variant, case_obj):
-        # GIVEN a database poulated with one SV
-        db = mongo_adapter.db
-        formated_variant = build_variant(
-            duptandem_variant, case_obj=case_obj, case_id=case_obj["case_id"]
-        )
-        mongo_adapter.add_structural_variant(formated_variant)
-
-        # Add second of same variant, changing the start and end position slightly
-        formated_variant_ = copy.deepcopy(formated_variant)
-        formated_variant_["pos"] = formated_variant_["pos"] + 2
-        formated_variant_["end"] = formated_variant_["end"] - 1
-        formated_variant_["case_id"] = "case_2"
-        mongo_adapter.add_structural_variant(formated_variant_)
-
-        # This should correspond to one structural variant document
-        mongo_svs = list(db.structural_variant.find())
-        assert len(mongo_svs) == 1
-        mongo_sv = mongo_svs[0]
-        assert mongo_sv["pos_sum"] == formated_variant["pos"] + formated_variant_["pos"]
-        # And two identity documents
-        mongo_identities = list(db.identity.find())
-        assert len(mongo_identities) == 2
-
-        # WHEN deleting the variant from the first case
-        mongo_adapter.delete_structural_variant(formated_variant)
-
-        # THEN the SV document should have the pos_sum equal to the pos of the
-        # SV from the second case
-        mongo_svs = list(db.structural_variant.find())
-        assert len(mongo_svs) == 1
-        mongo_sv = mongo_svs[0]
-        assert mongo_sv["pos_sum"] == formated_variant_["pos"]
-        # And one identity documents
-        mongo_identities = list(db.identity.find())
-        assert len(mongo_identities) == 1
-
-
-class TestHelperMethods:
-    def test_update_sv_metrics(self, mongo_adapter):
-        # GIVEN a mongo adapter
-
-        # WHEN cluster_len > 10000
-        cluster_len, interval_size = mongo_adapter._update_sv_metrics(
-            sv_type="INV", pos_mean=10000, end_mean=30000, max_window=3000
-        )
-        # THEN interval_size should be the cluster_len divided by 10
-        assert cluster_len == 20000
-        assert interval_size == round(20000 / 10, -2)
-
-        # WHEN cluster_len <10000
-        cluster_len, interval_size = mongo_adapter._update_sv_metrics(
-            sv_type="DUP", pos_mean=10000, end_mean=15000, max_window=3000
-        )
-
-        # THEN interval_size should be cluster_len divided by 5
-        assert cluster_len == 5000
-        assert interval_size == round(5000 / 5, -2)
-
-        # WHEN interval_size < 1000
-        cluster_len, interval_size = mongo_adapter._update_sv_metrics(
-            sv_type="DEL", pos_mean=10000, end_mean=10500, max_window=3000
-        )
-
-        # THEN interval_size should be cluster_len divided by 2
-        assert cluster_len == 500
-        assert interval_size == round(500 / 2, -2)
-
-        # WHEN interval size is > max_window
-        cluster_len, interval_size = mongo_adapter._update_sv_metrics(
-            sv_type="INV", pos_mean=100000, end_mean=200000, max_window=3000
-        )
-        # THEN interval size should be set to max_window
-        assert cluster_len == 100000
-        assert interval_size == 3000
-
-        # WHEN sv_type == BND
-        cluster_len, interval_size = mongo_adapter._update_sv_metrics(
-            sv_type="BND", pos_mean=1000, end_mean=2000, max_window=3000
-        )
-        # THEN cluster_len should be 10e10 and interval_size 2*max window
-        assert cluster_len == 10e10
-        assert interval_size == 2 * 3000

tests/utils/test_case.py

@@ -1,34 +0,0 @@
-import pytest
-from loqusdb.exceptions import CaseError
-from loqusdb.utils.case import update_case
-
-
-def test_update_case(case_obj, sv_case_obj):
-    ## GIVEN a case with snv info and a case with sv info
-    assert sv_case_obj["vcf_path"] is None
-    assert case_obj["vcf_path"] is not None
-    assert case_obj["vcf_sv_path"] is None
-    assert sv_case_obj["vcf_sv_path"] is not None
-
-    ## WHEN updating the case
-    updated_case = update_case(case_obj=sv_case_obj, existing_case=case_obj)
-
-    ## THEN assert that the cases have been merged without affecting the original cases
-    assert updated_case["vcf_path"] is not None
-    assert updated_case["vcf_path"] == case_obj["vcf_path"]
-    assert sv_case_obj["vcf_path"] is None
-
-    assert updated_case["vcf_sv_path"] is not None
-    assert updated_case["vcf_sv_path"] == sv_case_obj["vcf_sv_path"]
-    assert case_obj["vcf_sv_path"] is None
-
-    assert updated_case["nr_variants"] == case_obj["nr_variants"]
-    assert updated_case["nr_sv_variants"] == sv_case_obj["nr_sv_variants"]
-
-
-def test_update_existing_vcf(case_obj):
-    ## GIVEN a case object with VCF information
-    ## WHEN trying to update existing VCF information
-    ## THEN assert that a CaseError is raised
-    with pytest.raises(CaseError):
-        updated_case = update_case(case_obj, case_obj)

tests/utils/test_delete.py

@@ -1,73 +0,0 @@
-from loqusdb.utils.delete import delete
-from loqusdb.utils.load import load_database
-
-
-def test_delete_case(mongo_adapter, simple_case):
-    ## GIVEN a mongoadapter with a inserted case
-    db = mongo_adapter.db
-    db.case.insert_one(simple_case)
-    mongo_case = db.case.find_one()
-
-    assert mongo_case
-    ## WHEN deleting the case
-
-    mongo_adapter.delete_case(simple_case)
-    ## THEN assert that the case was deleted
-    mongo_case = db.case.find_one()
-
-    mongo_case = db.case.find_one()
-
-    assert mongo_case is None
-
-
-def test_delete_case_and_variants(vcf_path, ped_path, real_mongo_adapter, case_id, case_obj):
-    mongo_adapter = real_mongo_adapter
-    db = mongo_adapter.db
-
-    load_database(
-        adapter=mongo_adapter,
-        variant_file=vcf_path,
-        family_file=ped_path,
-        family_type="ped",
-    )
-
-    mongo_case = db.case.find_one()
-
-    assert mongo_case["case_id"] == case_id
-
-    delete(
-        adapter=mongo_adapter,
-        case_obj=case_obj,
-    )
-
-    mongo_case = db.case.find_one()
-
-    assert mongo_case is None
-
-    mongo_variant = db.variant.find_one()
-
-    assert mongo_variant is None
-
-
-def test_delete_structural_variants(vcf_path, ped_path, real_mongo_adapter, case_id, sv_case_obj):
-    # GIVEN a mongo adapter with an inserted case with SVs
-    mongo_adapter = real_mongo_adapter
-    db = mongo_adapter.db
-
-    load_database(
-        adapter=mongo_adapter,
-        variant_file=sv_case_obj["vcf_path"],
-        family_file=ped_path,
-        family_type="ped",
-        sv_file=sv_case_obj["vcf_sv_path"],
-    )
-
-    mongo_svs = db.structural_variant.find()
-    assert len(list(mongo_svs)) == 19
-
-    # WHEN deleteing the case
-    delete(adapter=mongo_adapter, case_obj=sv_case_obj)
-
-    # All structural variants should be deleted.
-    mongo_svs = db.structural_variant.find()
-    assert len(list(mongo_svs)) == 0