loqusdb 2.7.3__py3-none-any.whl → 2.7.8__py3-none-any.whl

tests/utils/test_delete_family.py

@@ -0,0 +1,30 @@
+import pytest
+from loqusdb.exceptions import CaseError
+
+
+def test_delete_family(mongo_adapter):
+    ## GIVEN a mongo adapter with a case
+    db = mongo_adapter.db
+    case = {"case_id": "1", "vcf_path": "path_to_vcf"}
+
+    db.case.insert_one(case)
+    mongo_case = db.case.find_one()
+    assert mongo_case["case_id"] == case["case_id"]
+
+    ## WHEN deleting the case
+    mongo_adapter.delete_case(case)
+
+    ## THEN assert that the case was deleted
+    mongo_case = db.case.find_one()
+
+    assert mongo_case is None
+
+
+def test_delete_non_existing_family(mongo_adapter):
+    ## WHEN deleting a non existing case
+    with pytest.raises(CaseError):
+        ## GIVEN a mongo adapter and a empty database
+        case = {"case_id": "1", "vcf_path": "path_to_vcf"}
+
+        ## THEN assert a CaseError is raised
+        mongo_adapter.delete_case(case)

tests/utils/test_delete_variant.py

@@ -0,0 +1,74 @@
+from loqusdb.build_models.variant import get_variant_id
+from loqusdb.utils.delete import delete_variants
+
+
+def test_delete_variants(real_mongo_adapter, het_variant, case_obj):
+    ## GIVEN a database with one variant
+    db = real_mongo_adapter.db
+    case_id = case_obj["case_id"]
+
+    db.variant.insert_one(
+        {
+            "_id": get_variant_id(het_variant),
+            "families": [case_id],
+            "observations": 1,
+        }
+    )
+
+    mongo_variant = db.variant.find_one()
+    assert mongo_variant["families"] == [case_id]
+
+    ## WHEN deleting the variant
+    delete_variants(adapter=real_mongo_adapter, vcf_obj=[het_variant], case_obj=case_obj)
+
+    mongo_variant = db.variant.find_one()
+
+    ## THEN assert that the variant was not found
+    assert mongo_variant is None
+
+
+def test_delete_variant(real_mongo_adapter, het_variant, case_obj):
+    ## GIVEN a database with one variant that is observed twice
+    db = real_mongo_adapter.db
+    case_id = case_obj["case_id"]
+
+    db.variant.insert_one(
+        {
+            "_id": get_variant_id(het_variant),
+            "families": [case_id, "2"],
+            "observations": 2,
+        }
+    )
+
+    mongo_variant = db.variant.find_one()
+    assert mongo_variant["observations"] == 2
+
+    ## WHEN deleting the variant for one case
+    delete_variants(
+        adapter=real_mongo_adapter,
+        vcf_obj=[het_variant],
+        case_obj=case_obj,
+        case_id="2",
+    )
+
+    mongo_variant = db.variant.find_one()
+
+    ## THEN assert that one case has been removed from 'families'
+    assert mongo_variant["families"] == [case_id]
+    ## THEN assert that the observation count is decreased
+    assert mongo_variant["observations"] == 1
+
+
+def test_delete_non_existing_variant(mongo_adapter, het_variant, case_obj):
+    """docstring for test_load_variants"""
+    ## GIVEN a mongo adapter to an empty database
+    db = mongo_adapter.db
+    case_id = case_obj["case_id"]
+
+    ## WHEN deleting the variants
+    delete_variants(adapter=mongo_adapter, vcf_obj=[het_variant], case_obj=case_obj)
+
+    # THEN assert nothing happens
+    mongo_variant = db.variant.find_one()
+
+    assert mongo_variant == None

tests/utils/test_get_family.py

@@ -0,0 +1,13 @@
+import pytest
+from loqusdb.exceptions import CaseError
+from loqusdb.utils.case import get_case
+
+
+def test_get_family(case_lines):
+    family = get_case(case_lines)
+    assert family.family_id == "recessive_trio"
+
+
+def test_get_multiple_families(two_cases):
+    with pytest.raises(CaseError):
+        family = get_case(two_cases)

tests/utils/test_load_database.py

@@ -0,0 +1,52 @@
+import pytest
+from loqusdb.exceptions import CaseError
+from loqusdb.utils.load import load_database
+
+
+def test_load_database(vcf_path, ped_path, real_mongo_adapter, case_id):
+    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
+
+
+def test_load_database_alternative_ped(vcf_path, ped_path, real_mongo_adapter, case_id):
+    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",
+        case_id="alternative",
+    )
+
+    mongo_case = db.case.find_one()
+    mongo_variant = db.variant.find_one()
+
+    assert mongo_case["case_id"] == "alternative"
+    assert mongo_variant["families"] == ["alternative"]
+
+
+def test_load_database_wrong_ped(vcf_path, funny_ped_path, real_mongo_adapter):
+    mongo_adapter = real_mongo_adapter
+    ## GIVEN a vcf and ped file with wrong individuals
+    ## WHEN loading the information
+    ## THEN Error should be raised since individuals is not in vcf
+    with pytest.raises(CaseError):
+        load_database(
+            adapter=mongo_adapter,
+            variant_file=vcf_path,
+            family_file=funny_ped_path,
+            family_type="ped",
+        )

tests/utils/test_load_family.py

@@ -0,0 +1,69 @@
+import pytest
+from loqusdb.exceptions import CaseError
+
+from loqusdb.utils.load import update_case, load_case
+
+
+def test_load_family(mongo_adapter, simple_case):
+    ## GIVEN a adapter to an empty database
+    db = mongo_adapter.db
+
+    ## WHEN loading a family to the database
+    mongo_adapter.add_case(simple_case)
+
+    ## THEN assert that the case was loaded
+    mongo_case = db.case.find_one()
+    assert mongo_case["case_id"] == simple_case["case_id"]
+
+
+def test_load_same_family_twice(mongo_adapter, simple_case):
+    ## GIVEN a adapter to an empty database
+    db = mongo_adapter.db
+
+    ## WHEN loading a family to the database twice
+    mongo_adapter.add_case(simple_case)
+
+    ## THEN assert that a CaseError is raised
+    with pytest.raises(CaseError):
+        mongo_adapter.add_case(simple_case)
+
+
+def test_update_case(case_obj, sv_case_obj):
+    ## GIVEN an existing case and a case with new info
+
+    ## WHEN merging the two case objs
+    updated_case = update_case(sv_case_obj, case_obj)
+
+    ## THEN assert that the updated case includes information from both cases
+    assert updated_case["sv_individuals"] == sv_case_obj["sv_individuals"]
+    assert updated_case["sv_individuals"] != case_obj["sv_individuals"]
+
+    assert updated_case["_sv_inds"] == sv_case_obj["_sv_inds"]
+    assert updated_case["_sv_inds"] != case_obj["_sv_inds"]
+
+    assert updated_case["nr_variants"] == case_obj["nr_variants"]
+    assert updated_case["nr_sv_variants"] == sv_case_obj["nr_sv_variants"]
+
+
+def test_update_case_same_vcf(case_obj, sv_case_obj):
+    ## GIVEN an existing case and a case with new info
+    sv_case_obj["vcf_path"] = case_obj["vcf_path"]
+    ## WHEN merging the two case objs
+    ## THEN assert that a CaseError is raised since we are trying to modify existing VCF
+    with pytest.raises(CaseError):
+        updated_case = update_case(sv_case_obj, case_obj)
+
+
+def test_load_complete_case(mongo_adapter, complete_case_obj):
+    ## GIVEN a case that includes both svs and snvs
+    db = mongo_adapter.db
+
+    ## WHEN loading the case
+    case_obj = load_case(mongo_adapter, complete_case_obj)
+    ## THEN assert that all info is added
+    loaded_case = db.case.find_one()
+
+    assert len(loaded_case["individuals"]) == 3
+    assert len(loaded_case["sv_individuals"]) == 3
+    assert loaded_case["nr_variants"] > 0
+    assert loaded_case["nr_sv_variants"] > 0

tests/utils/test_load_variants.py

@@ -0,0 +1,225 @@
+from cyvcf2 import VCF
+
+from loqusdb.utils.load import load_variants
+
+
+def test_load_variants(real_mongo_adapter, het_variant, case_obj):
+    mongo_adapter = real_mongo_adapter
+    ## GIVEN an adapter and a vcf with one heterozygote variant
+    db = mongo_adapter.db
+
+    vcf = []
+    vcf.append(het_variant)
+    mongo_variant = db.variant.find_one()
+
+    assert mongo_variant == None
+
+    ## WHEN loading the variant into the database
+    load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf,
+        case_obj=case_obj,
+    )
+
+    mongo_variant = db.variant.find_one()
+
+    ## THEN assert that the variant is loaded correct
+    assert mongo_variant["families"] == [case_obj["case_id"]]
+    assert mongo_variant["observations"] == 1
+    assert mongo_variant["homozygote"] == 0
+    assert mongo_variant["hemizygote"] == 0
+
+
+def test_load_homozygote(real_mongo_adapter, hom_variant, case_obj):
+    mongo_adapter = real_mongo_adapter
+    ## GIVEN an adapter and a vcf with one homozygote variant
+    db = mongo_adapter.db
+
+    vcf = []
+    vcf.append(hom_variant)
+    assert db.variant.find_one() == None
+
+    ## WHEN loading the variant into the database
+    load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf,
+        case_obj=case_obj,
+    )
+    mongo_variant = db.variant.find_one()
+
+    ## THEN assert that the variant is loaded correct
+    assert mongo_variant["families"] == [case_obj["case_id"]]
+    assert mongo_variant["observations"] == 1
+    assert mongo_variant["homozygote"] == 1
+    assert mongo_variant["hemizygote"] == 0
+
+
+def test_load_hemizygote(real_mongo_adapter, hem_variant, case_obj):
+    mongo_adapter = real_mongo_adapter
+    ## GIVEN an adapter and a vcf with one hemizygote variant
+    db = mongo_adapter.db
+
+    vcf = []
+    vcf.append(hem_variant)
+
+    assert db.variant.find_one() == None
+
+    ## WHEN loading the variant into the database
+    load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf,
+        case_obj=case_obj,
+    )
+    mongo_variant = db.variant.find_one()
+
+    ## THEN assert that the variant is loaded correct
+    assert mongo_variant["families"] == [case_obj["case_id"]]
+    assert mongo_variant["observations"] == 1
+    assert mongo_variant["homozygote"] == 0
+    assert mongo_variant["hemizygote"] == 1
+
+
+def test_load_par_variant(real_mongo_adapter, par_variant, case_obj):
+    mongo_adapter = real_mongo_adapter
+
+    ## GIVEN an adapter and a vcf with one PAR variant
+    db = mongo_adapter.db
+
+    vcf = []
+    vcf.append(par_variant)
+
+    assert db.variant.find_one() == None
+
+    ## WHEN loading the variant into the database
+    load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf,
+        case_obj=case_obj,
+    )
+    mongo_variant = db.variant.find_one()
+
+    ## THEN assert that the variant is loaded correct
+    assert mongo_variant["families"] == [case_obj["case_id"]]
+    assert mongo_variant["observations"] == 1
+    assert mongo_variant["homozygote"] == 0
+    assert mongo_variant["hemizygote"] == 0
+
+
+def test_load_two_variants(real_mongo_adapter, het_variant, case_obj):
+    mongo_adapter = real_mongo_adapter
+    ## GIVEN an adapter and a vcf with tho heterygote variants
+    db = mongo_adapter.db
+
+    vcf = []
+    vcf.append(het_variant)
+    vcf.append(het_variant)
+
+    ## WHEN loading the variants into the database
+    load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf,
+        case_obj=case_obj,
+    )
+
+    ## THEN assert that the variant is loaded correct
+    mongo_variant = db.variant.find_one()
+
+    assert mongo_variant["observations"] == 2
+
+
+def test_load_variants_skip_case_id(real_mongo_adapter, het_variant, case_obj):
+    mongo_adapter = real_mongo_adapter
+    ## GIVEN an adapter and a vcf with tho heterygote variants
+    db = mongo_adapter.db
+
+    vcf = []
+    vcf.append(het_variant)
+
+    ## WHEN loading the variants into the database
+    load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf,
+        case_obj=case_obj,
+        skip_case_id=True,
+    )
+
+    mongo_variant = db.variant.find_one()
+
+    ## THEN assert that the variant is loaded correct
+    assert mongo_variant.get("families") == None
+
+
+def test_load_same_variant_different_case(real_mongo_adapter, het_variant, case_obj):
+    mongo_adapter = real_mongo_adapter
+    ## GIVEN an adapter and a vcf
+    db = mongo_adapter.db
+
+    vcf = []
+    vcf.append(het_variant)
+
+    ## WHEN loading the variant into the database
+    load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf,
+        case_obj=case_obj,
+    )
+
+    case_id = case_obj["case_id"]
+    case_id2 = "2"
+    case_obj["case_id"] = case_id2
+
+    load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf,
+        case_obj=case_obj,
+    )
+
+    mongo_variant = db.variant.find_one()
+
+    assert mongo_variant["observations"] == 2
+    assert mongo_variant["families"] == [case_id, case_id2]
+
+
+def test_load_case_variants(real_mongo_adapter, case_obj):
+    mongo_adapter = real_mongo_adapter
+
+    db = mongo_adapter.db
+    ## GIVEN a mongo adatper with snv variant file
+    vcf_obj = VCF(case_obj["vcf_path"])
+    ## WHEN loading the variants
+    nr_variants = load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf_obj,
+        case_obj=case_obj,
+    )
+
+    nr_loaded = 0
+    for nr_loaded, variant in enumerate(db.variant.find(), 1):
+        pass
+    ## THEN assert that the correct number of variants was loaded
+    assert nr_loaded > 0
+    assert nr_loaded == case_obj["nr_variants"]
+
+
+def test_load_sv_case_variants(mongo_adapter, sv_case_obj):
+    db = mongo_adapter.db
+    ## GIVEN a mongo adatper with snv variant file
+    vcf_obj = VCF(sv_case_obj["vcf_sv_path"])
+    ## WHEN loading the variants
+    nr_variants = load_variants(
+        adapter=mongo_adapter,
+        vcf_obj=vcf_obj,
+        case_obj=sv_case_obj,
+        variant_type="sv",
+    )
+
+    nr_loaded_svs = 0
+    for nr_loaded_svs, variant in enumerate(db.structural_variant.find(), 1):
+        pass
+    nr_loaded_snvs = 0
+    for nr_loaded_snvs, variant in enumerate(db.variant.find(), 1):
+        pass
+    ## THEN assert that the correct number of variants was loaded
+    assert nr_loaded_svs > 0
+    assert nr_loaded_snvs == 0
+    assert nr_loaded_svs == sv_case_obj["nr_sv_variants"]

tests/utils/test_migrate.py

@@ -0,0 +1,38 @@
+from loqusdb.utils.migrate import migrate_database
+
+
+def test_migrate_one_variant(mongo_adapter):
+    ##GIVEN a adapter to an empty old database
+    adapter = mongo_adapter
+    assert sum(1 for i in adapter.get_variants()) == 0
+
+    ##WHEN inserting a old style variant and updating the database
+    chrom = "1"
+    pos = 880086
+    ref = "T"
+    alt = "C"
+    hom = hem = 0
+    obs = 3
+    families = ["recessive_trio", "1", "2"]
+    variant = {
+        "_id": "_".join([chrom, str(pos), ref, alt]),
+        "homozygote": hom,
+        "hemizygote": hem,
+        "observations": obs,
+        "families": families,
+    }
+    adapter.db.variant.insert_one(variant)
+    ##THEN assert that the variant was updated correct
+
+    nr_updated = migrate_database(adapter)
+    assert nr_updated == 1
+
+    migrated_variant = adapter.db.variant.find_one()
+
+    assert migrated_variant["chrom"] == chrom
+    assert migrated_variant["start"] == pos
+    assert migrated_variant["end"] == pos
+    assert migrated_variant["homozygote"] == hom
+    assert migrated_variant["hemizygote"] == hem
+    assert migrated_variant["observations"] == obs
+    assert migrated_variant["families"] == families

tests/utils/test_profiling.py

@@ -0,0 +1,68 @@
+import pytest
+from loqusdb.exceptions import ProfileError
+from loqusdb.utils.load import load_profile_variants, load_case
+from loqusdb.utils.profiling import get_profiles, profile_match, compare_profiles, check_duplicates
+from loqusdb.utils.vcf import check_vcf
+
+
+def test_get_profiles(real_mongo_adapter, profile_vcf_path, zipped_vcf_path):
+    # Load profile variants
+    load_profile_variants(real_mongo_adapter, profile_vcf_path)
+
+    vcf_info = check_vcf(zipped_vcf_path)
+
+    # Get profiles from vcf
+    profiles = get_profiles(real_mongo_adapter, zipped_vcf_path)
+
+    # Assert that all individuals are included
+    assert list(profiles.keys()) == vcf_info["individuals"]
+
+    # Assert that profile strings are of same lengths
+    for i, individual in enumerate(profiles.keys()):
+        if i == 0:
+            length = len(profiles[individual])
+        assert len(profiles[individual]) == length
+
+
+def test_profile_match(real_mongo_adapter, profile_vcf_path, profile_list, case_obj):
+    # Load profile variants
+    load_profile_variants(real_mongo_adapter, profile_vcf_path)
+
+    # Load case having profiles profile_list
+    load_case(real_mongo_adapter, case_obj)
+
+    # Get profiles from vcf
+    profiles = {"test_individual": profile_list}
+
+    # Assert that error is raised
+    with pytest.raises(ProfileError) as error:
+        profile_match(real_mongo_adapter, profiles)
+
+
+def test_check_duplicates(real_mongo_adapter, profile_vcf_path, profile_list, case_obj):
+    # Load profile variants
+    load_profile_variants(real_mongo_adapter, profile_vcf_path)
+    # Load case having profiles profile_list
+    load_case(real_mongo_adapter, case_obj)
+    # Create profiles dictionary
+    profiles = {"test_individual": profile_list}
+    # match profiles to the profiles in the database
+    match = check_duplicates(real_mongo_adapter, profiles, hard_threshold=0.95)
+    # This should match with the sample in the database
+    assert match["profile"] == profile_list
+
+    # Change last genotype, now no matches should be found
+    profiles = {"test_individual": profile_list[:-1] + ["NN"]}
+    match = check_duplicates(real_mongo_adapter, profiles, hard_threshold=0.80)
+    assert match is None
+
+    # Lower threshold. Now match should be found
+    match = check_duplicates(real_mongo_adapter, profiles, hard_threshold=0.75)
+    assert match["profile"] == profile_list
+
+
+def test_compare_profiles():
+    assert compare_profiles(["AA", "CC"], ["AA", "CC"]) == 1.0
+    assert compare_profiles(["AA", "CC"], ["GG", "CC"]) == 0.5
+    assert compare_profiles(["AC", "CG"], ["TC", "CG"]) == 0.5
+    assert compare_profiles(["AC", "GT"], ["AA", "GG"]) == 0.0

tests/vcf_tools/test_check_par.py

@@ -0,0 +1,67 @@
+"""
+tests/vcf_tools/check_par.py
+
+Test if variants are in the Pseudo Autosomal Recessive region.
+"""
+
+from loqusdb.build_models.variant import check_par
+
+
+def test_par_region_X_lower():
+    chrom = "X"
+    pos = 60001
+    assert check_par(chrom, pos)
+
+
+def test_par_region_X_middle():
+    chrom = "X"
+    pos = 1000000
+    assert check_par(chrom, pos)
+
+
+def test_par_region_X_upper():
+    chrom = "X"
+    pos = 2649520
+    assert check_par(chrom, pos)
+
+
+def test_par_region_X_second():
+    chrom = "X"
+    pos = 154931044
+    assert check_par(chrom, pos)
+
+
+def test_non_par_X_region():
+    chrom = "X"
+    pos = 60000
+    assert not check_par(chrom, pos)
+
+
+def test_par_wrong_chrom():
+    chrom = "1"
+    pos = 60000
+    assert not check_par(chrom, pos)
+
+
+def test_par_region_Y_lower():
+    chrom = "Y"
+    pos = 10001
+    assert check_par(chrom, pos)
+
+
+def test_par_region_Y_middle():
+    chrom = "Y"
+    pos = 1000000
+    assert check_par(chrom, pos)
+
+
+def test_par_region_Y_upper():
+    chrom = "Y"
+    pos = 2649520
+    assert check_par(chrom, pos)
+
+
+def test_par_region_Y_second():
+    chrom = "Y"
+    pos = 59034050
+    assert check_par(chrom, pos)