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

tests/vcf_tools/test_check_vcf.py

@@ -1,64 +0,0 @@
-import pytest
-from loqusdb.exceptions import VcfError
-from loqusdb.utils.vcf import check_vcf
-
-
-def test_check_vcf_correct(vcf_path):
-    ## GIVEN a vcf file and a counter that checks the number of variants
-    true_nr = 0
-
-    with open(vcf_path, "r") as f:
-        for line in f:
-            if not line.startswith("#"):
-                true_nr += 1
-
-    ## WHEN collecting the VCF info
-    vcf_info = check_vcf(vcf_path)
-
-    ## THEN assert that the number of variants collected is correct
-    assert vcf_info["nr_variants"] == true_nr
-    ## THEN assert that the variant type is correct
-    assert vcf_info["variant_type"] == "snv"
-
-
-def test_check_vcf_double_variant(double_vcf_path):
-    ## GIVEN a variant file where a variant is duplicated
-    ## WHEN checking the vcf
-    ## THEN assert that the function raises a VcfError
-    with pytest.raises(VcfError):
-        check_vcf(double_vcf_path)
-
-
-def test_check_vcf_unsorted(unsorted_vcf_path):
-    ## GIVEN a vcf file with unsorted variants
-    ## WHEN checking the vcf
-    ## THEN assert that the function raises a VcfError
-    with pytest.raises(VcfError):
-        check_vcf(unsorted_vcf_path)
-
-
-def test_check_sv_vcf(sv_vcf_path):
-    ## GIVEN a vcf file and a counter that checks the number of variants
-    true_nr = 0
-
-    with open(sv_vcf_path, "r") as f:
-        for line in f:
-            if not line.startswith("#"):
-                true_nr += 1
-
-    ## WHEN collecting the VCF info
-    vcf_info = check_vcf(sv_vcf_path, "sv")
-
-    ## THEN assert that the number of variants collected is correct
-    assert vcf_info["nr_variants"] == true_nr
-    ## THEN assert that the variant type is correct
-    assert vcf_info["variant_type"] == "sv"
-
-
-def test_check_vcf_wrong_type(sv_vcf_path):
-    ## GIVEN a sv vcf file
-
-    ## WHEN collecting the VCF info with wrong variant type
-    ## THEN assert that a VcfError is raised
-    with pytest.raises(VcfError):
-        vcf_info = check_vcf(sv_vcf_path, "snv")

tests/vcf_tools/test_format_sv_variant.py

@@ -1,102 +0,0 @@
-from loqusdb.build_models.variant import build_variant
-
-
-def test_format_indel(del_variant, case_obj):
-    ## GIVEN a SV deletion
-    variant = del_variant
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-    expected_id = "_".join([variant.CHROM, str(variant.POS), variant.REF, variant.ALT[0]])
-
-    ## THEN assert the sv is parsed correct
-    assert formated_variant
-    assert formated_variant["variant_id"] == expected_id
-    assert formated_variant["chrom"] == variant.CHROM
-    assert formated_variant["end_chrom"] == variant.CHROM
-    assert formated_variant["pos"] == variant.POS
-    assert formated_variant["end"] == variant.INFO["END"]
-    assert formated_variant["sv_len"] == abs(variant.INFO["SVLEN"])
-
-    assert formated_variant["ref"] == variant.REF
-    assert formated_variant["alt"] == variant.ALT[0]
-    assert formated_variant["sv_type"] == "DEL"
-    assert formated_variant["case_id"] == case_id
-    assert formated_variant["homozygote"] == 0
-    assert formated_variant["hemizygote"] == 0
-
-
-def test_format_small_ins(small_insert_variant, case_obj):
-    ## GIVEN a small insertion (This means that the insertion is included in ALT field)
-    variant = small_insert_variant
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    ## THEN assert the sv is parsed correct
-    assert formated_variant["chrom"] == variant.CHROM
-    assert formated_variant["end_chrom"] == variant.CHROM
-    assert formated_variant["pos"] == variant.POS
-    assert formated_variant["end"] == variant.POS + abs(variant.INFO["SVLEN"])
-    assert formated_variant["sv_len"] == abs(variant.INFO["SVLEN"])
-
-    assert formated_variant["ref"] == variant.REF
-    assert formated_variant["alt"] == variant.ALT[0]
-    assert formated_variant["sv_type"] == "INS"
-
-
-def test_format_insertion(insertion_variant, case_obj):
-    ## GIVEN a small insertion (This means that the insertion is included in ALT field)
-    variant = insertion_variant
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    ## THEN assert the sv is parsed correct
-    assert formated_variant["chrom"] == variant.CHROM
-    assert formated_variant["end_chrom"] == variant.CHROM
-    assert formated_variant["pos"] == variant.POS
-    assert formated_variant["end"] == variant.INFO["END"]
-    assert formated_variant["sv_len"] == 0
-
-    assert formated_variant["ref"] == variant.REF
-    assert formated_variant["alt"] == variant.ALT[0]
-    assert formated_variant["sv_type"] == "INS"
-
-
-def test_format_dup_tandem(duptandem_variant, case_obj):
-    ## GIVEN a small insertion (This means that the insertion is included in ALT field)
-    variant = duptandem_variant
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    ## THEN assert the sv is parsed correct
-    assert formated_variant["chrom"] == variant.CHROM
-    assert formated_variant["end_chrom"] == variant.CHROM
-    assert formated_variant["pos"] == variant.POS
-    assert formated_variant["end"] == variant.INFO["END"]
-    assert formated_variant["sv_len"] == abs(variant.INFO["SVLEN"])
-
-    assert formated_variant["ref"] == variant.REF
-    assert formated_variant["alt"] == variant.ALT[0]
-    assert formated_variant["sv_type"] == "DUP"
-
-
-def test_format_translocation(translocation_variant, case_obj):
-    ## GIVEN a small insertion (This means that the insertion is included in ALT field)
-    variant = translocation_variant
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    ## THEN assert the sv is parsed correct
-    assert formated_variant["chrom"] == variant.CHROM
-    assert formated_variant["end_chrom"] == "11"
-    assert formated_variant["pos"] == variant.POS
-    assert formated_variant["end"] == 119123896
-    assert formated_variant["sv_len"] == float("inf")
-
-    assert formated_variant["ref"] == variant.REF
-    assert formated_variant["alt"] == variant.ALT[0]
-    assert formated_variant["sv_type"] == "BND"

tests/vcf_tools/test_format_variant.py

@@ -1,113 +0,0 @@
-from loqusdb.build_models.variant import build_variant, GENOTYPE_MAP
-
-
-def test_format_variant(het_variant, case_obj):
-    ## GIVEN a parsed variant
-    variant = het_variant
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    expected_id = "_".join([variant.CHROM, str(variant.POS), variant.REF, variant.ALT[0]])
-
-    ## THEN assert it was built in a correct way
-    assert formated_variant
-    assert formated_variant["variant_id"] == expected_id
-    assert formated_variant["chrom"] == variant.CHROM
-    assert formated_variant["pos"] == variant.POS
-    assert formated_variant["ref"] == variant.REF
-    assert formated_variant["alt"] == variant.ALT[0]
-    assert formated_variant["case_id"] == case_id
-    assert formated_variant["homozygote"] == 0
-
-
-def test_format_variant_no_qual(variant_no_gq, case_obj):
-    ## GIVEN a variant without GQ
-    variant = variant_no_gq
-    ## And that has a missing QUAL value
-    variant.QUAL = None
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant using a QUAL threshold
-    formated_variant = build_variant(
-        variant=variant, case_obj=case_obj, case_id=case_id, gq_qual=True, gq_threshold=20
-    )
-    ## THEN assert that None is returned since requirements are not fulfilled
-    assert formated_variant is None
-
-
-def test_format_variant_no_gq(variant_no_gq, case_obj):
-    ## GIVEN a variant without GQ
-    variant = variant_no_gq
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant using a GQ threshold
-    formated_variant = build_variant(
-        variant=variant, case_obj=case_obj, case_id=case_id, gq_threshold=20
-    )
-    ## THEN assert that None is returned since requirements are not fulfilled
-    assert formated_variant is None
-
-
-def test_format_variant_chr_prefix(variant_chr, case_obj):
-    ## GIVEN a variant with 'chr' prefix in chromosome name
-    variant = variant_chr
-    assert variant.CHROM.startswith("chr")
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant using a GQ threshold
-    formated_variant = build_variant(
-        variant=variant, case_obj=case_obj, case_id=case_id, gq_threshold=20
-    )
-    ## THEN assert that the 'chr' part has been stripped away
-    assert formated_variant["chrom"] == variant.CHROM[3:]
-
-
-def test_format_variant_no_family_id(het_variant, case_obj):
-    ## GIVEN a parsed variant
-    variant = het_variant
-    case_id = case_obj["case_id"]
-    ## WHEN parsing the variant telling that 'case_id' is None
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=None)
-    ## THEN assert that case_id was not added
-    assert formated_variant.get("case_id") == None
-    assert formated_variant["homozygote"] == 0
-    assert formated_variant["hemizygote"] == 0
-
-
-def test_format_homozygote_variant(hom_variant, case_obj):
-    ## GIVEN a parsed hom variant
-    variant = hom_variant
-    case_id = case_obj["case_id"]
-
-    ## WHEN parsing the variant
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    ## THEN assert that the variant has hom count
-    assert formated_variant["homozygote"] == 1
-    assert formated_variant["hemizygote"] == 0
-
-
-def test_format_hemizygote_variant(hem_variant, case_obj):
-    ## GIVEN a parsed hemizygous variant
-    variant = hem_variant
-    case_id = case_obj["case_id"]
-
-    ## WHEN parsing the variant
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    ## THEN assert that hemizygote count is 1
-    assert formated_variant["homozygote"] == 0
-    assert formated_variant["hemizygote"] == 1
-
-
-def test_format_variant_no_call(variant_no_call, case_obj):
-    ## GIVEN a parsed variant with no call in all individuals
-    variant = variant_no_call
-    case_id = case_obj["case_id"]
-
-    for call in variant.gt_types:
-        assert GENOTYPE_MAP[call] in ["no_call", "hom_ref"]
-
-    ## WHEN parsing the variant
-    formated_variant = build_variant(variant=variant, case_obj=case_obj, case_id=case_id)
-
-    ## THEN assert that the result is None
-    assert formated_variant is None

tests/vcf_tools/test_vcf.py

@@ -1,63 +0,0 @@
-import pytest
-from cyvcf2 import VCF
-from loqusdb.utils.vcf import get_file_handle, check_vcf
-
-
-def test_get_file_handle(vcf_path):
-    ## GIVEN the path to a vcf
-
-    ## WHEN geting the file handle
-    vcf = get_file_handle(vcf_path)
-
-    ## THEN assert that a VCF object is returned
-    assert type(vcf) is VCF
-
-
-def test_get_zipped_file_handle(zipped_vcf_path):
-    ## GIVEN the path to a zipped vcf
-
-    ## WHEN geting the file handle
-    vcf = get_file_handle(zipped_vcf_path)
-
-    ## THEN assert that a VCF object is returned
-    assert type(vcf) is VCF
-
-
-def test_get_vcf_non_vcf(ped_path):
-    ## GIVEN the path to a non vcf
-
-    ## WHEN geting the file handle
-
-    ## THEN assert that a IOError is raised
-    with pytest.raises(IOError):
-        vcf = get_file_handle(ped_path)
-
-
-def test_get_vcf_non_existing():
-    ## GIVEN the path to a non existing file
-
-    ## WHEN geting the file handle
-
-    ## THEN assert that a IOError is raised
-    with pytest.raises(IOError):
-        vcf = get_file_handle("hello")
-
-
-def test_check_vcf(vcf_path):
-    ## GIVEN the path to a vcf
-    nr_variants = 0
-    vcf = VCF(vcf_path)
-    inds = vcf.samples
-    for var in vcf:
-        nr_variants += 1
-    ## WHEN checking the vcf
-    vcf_info = check_vcf(vcf_path)
-
-    ## THEN assert that the number of variants is correct
-    assert vcf_info["nr_variants"] == nr_variants
-
-    ## THEN assert that the individuals are returned
-    assert vcf_info["individuals"] == inds
-
-    ## THEN assert that the variant type is correct
-    assert vcf_info["variant_type"] == "snv"