def test_metafile_provided_not_supported_anymore():
with pytest.raises(RuntimeError):
read_bgen(
example_filepath("haplotypes.bgen"),
metafile_filepath=example_filepath("haplotypes.bgen.metadata.valid"),
verbose=False,
)
def test_bgen_samples_outside_bgen_unreadable(tmp_path):
bgen_filepath = example_filepath("complex.23bits.bgen")
samples_filepath = tmp_path / "complex.sample"
copyfile(example_filepath("complex.sample"), samples_filepath)
with noread_permission(samples_filepath):
with pytest.raises(PermissionError):
read_bgen(bgen_filepath, samples_filepath=samples_filepath, verbose=False)
def test_bgen_reader_with_wrong_metadata_file():
filepath = example_filepath("example.32bits.bgen")
filepath.touch()
metafile_filepath = example_filepath("wrong.metadata")
metafile_filepath.touch() # make sure that the metafile has a later timestamp (otherwise, it might be re-created)
with pytest.raises(RuntimeError):
read_bgen(filepath, verbose=False, metafile_filepath=metafile_filepath)
def test_metafile_not_provided_no_permission_to_create(tmp_path):
src = example_filepath("haplotypes.bgen")
dst = tmp_path / "haplotypes.bgen"
copyfile(src, dst)
path = os.path.dirname(dst)
with nowrite_permission(path):
with pytest.warns(UserWarning):
read_bgen(dst, verbose=False)
def test_bgen_reader_with_nonexistent_metadata_file():
filepath = example_filepath("example.32bits.bgen")
folder = os.path.dirname(filepath)
metafile_filepath = os.path.join(folder, "nonexistent.metadata")
with pytest.raises(FileNotFoundError):
with pytest.warns(UserWarning):
read_bgen(filepath, verbose=False, metafile_filepath=metafile_filepath)
def test_allele_expectation_interface():
bgen = read_bgen(example_filepath("haplotypes.bgen"), verbose=False)
with pytest.raises(ValueError):
allele_expectation(bgen, 1)
bgen = read_bgen(example_filepath("complex.23bits.bgen"), verbose=False)
e = allele_expectation(bgen, 3)
assert_allclose(
e,
[[1.0, 0.0, 0.0], [2.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 2.0, 0.0]])
def test_bgen_reader_phased_genotype():
filepath = example_filepath("haplotypes.bgen")
bgen = read_bgen(filepath, verbose=False)
variants = bgen["variants"]
samples = bgen["samples"]
v = variants.loc[0].compute()
assert_equal(v["chrom"].values[0], "1")
assert_equal(v["id"].values[0], "SNP1")
assert_equal(v["nalleles"].values[0], 2)
assert_equal(v["allele_ids"].values[0], "A,G")
assert_equal(v["pos"].values[0], 1)
assert_equal(v["rsid"].values[0], "RS1")
v = variants.loc[2].compute()
assert_equal(v["chrom"].values[0], "1")
assert_equal(v["id"].values[0], "SNP3")
assert_equal(v["nalleles"].values[0], 2)
assert_equal(v["allele_ids"].values[0], "A,G")
assert_equal(v["pos"].values[0], 3)
assert_equal(v["rsid"].values[0], "RS3")
assert_equal(samples.loc[0], "sample_0")
assert_equal(samples.loc[2], "sample_2")
n = samples.shape[0]
assert_equal(samples.loc[n - 1], "sample_3")
g = bgen["genotype"][0].compute()
assert_allclose(g["probs"][0], [1.0, 0.0, 1.0, 0.0])
k = len(variants)
n = len(samples)
g = bgen["genotype"][k - 1].compute()
assert_allclose(g["probs"][n - 1], [1.0, 0.0, 0.0, 1.0])
def test_large_file(large_bgen_filepath):
data = read_bgen(large_bgen_filepath, verbose=True)
variants = data["variants"]
samples = data["samples"]
genotype = data["genotype"]
df = variants[(variants["chrom"] == "3")
& (variants["pos"] > 250000)
& (variants["pos"] < 290000)].compute()
assert_equal(len(df), 14)
assert_equal(df.iloc[0]["id"], "")
assert_equal(df.iloc[0]["rsid"], "Human_STR_911968")
assert_equal(df.iloc[0]["nalleles"], 2)
assert_equal(df.iloc[0]["allele_ids"], "<CNV>,CACAC")
assert_equal(df.iloc[0]["vaddr"], 73115140)
assert_equal(samples[382], "SAMEA2586986")
assert_equal(df.index[0], 283970)
g = genotype[df.index[0]].compute()
assert_equal(g["probs"].shape, (415, 3))
assert_allclose(g["probs"][410, :],
[0.0, 0.4268863965819791, 0.5731136034180209])
assert_equal(g["phased"], False)
assert_equal(g["missing"][3], False)
assert_equal(g["ploidy"][3], 2)
def test_custom_meta_path():
filepath = example_filepath2("example.bgen")
custom_path = Path(BGEN_READER_CACHE_HOME, "submeta")
try:
os.mkdir(custom_path)
except FileExistsError:
pass
custom_meta_path(custom_path)
read_bgen(filepath)
open_bgen(filepath)
assert len([path for path in Path(custom_path).iterdir()]) == 2, "Failed to write files to custom directory"
os.remove(Path(custom_path, filepath.name + ".metadata2.mmm"))
os.remove(Path(custom_path, filepath.name + ".metafile"))
def test_bgen_reader():
folder = os.path.dirname(os.path.abspath(__file__)).encode()
filepath = os.path.join(folder, b"example.32bits.bgen")
bgen = read_bgen(filepath, verbose=False)
variants = bgen['variants']
samples = bgen['samples']
genotype = bgen['genotype']
assert_equal(variants.loc[0, 'chrom'], '01')
assert_equal(variants.loc[0, 'id'], 'SNPID_2')
assert_equal(variants.loc[0, 'nalleles'], 2)
assert_equal(variants.loc[0, 'allele_ids'], "A,G")
assert_equal(variants.loc[0, 'pos'], 2000)
assert_equal(variants.loc[0, 'rsid'], 'RSID_2')
assert_equal(variants.loc[7, 'chrom'], '01')
assert_equal(variants.loc[7, 'id'], 'SNPID_9')
assert_equal(variants.loc[7, 'nalleles'], 2)
assert_equal(variants.loc[7, 'allele_ids'], "A,G")
assert_equal(variants.loc[7, 'pos'], 9000)
assert_equal(variants.loc[7, 'rsid'], 'RSID_9')
n = variants.shape[0]
assert_equal(variants.loc[n - 1, 'chrom'], '01')
assert_equal(variants.loc[n - 1, 'id'], 'SNPID_200')
assert_equal(variants.loc[n - 1, 'nalleles'], 2)
assert_equal(variants.loc[n - 1, 'allele_ids'], "A,G")
assert_equal(variants.loc[n - 1, 'pos'], 100001)
assert_equal(variants.loc[n - 1, 'rsid'], 'RSID_200')
assert_equal(samples.loc[0, 'id'], 'sample_001')
assert_equal(samples.loc[7, 'id'], 'sample_008')
n = samples.shape[0]
assert_equal(samples.loc[n - 1, 'id'], 'sample_500')
def process_metadata(self, metadata_file, show_progress=False):
# TODO Should make this an explicit requirement rather than hardcoding.
withdrawn_ids = set()
with open("ukbb_withdrawn.csv") as f:
for line in f:
withdrawn_ids.add(int(line))
# The sample IDs aren't in the BGEN file so we have to match by the Order
# field, which gives the order that each sample is at in the BGEN (0 based).
metadata_df = pd.read_csv(metadata_file)
metadata_df.sort_values(by="Order", inplace=True)
metadata_df = metadata_df.set_index("Order")
bgen = bgen_reader.read_bgen(self.data_file, verbose=False)
sample_df = bgen['samples']
keep_samples = []
row_iter = tqdm.tqdm(metadata_df.iterrows(),
total=len(metadata_df),
disable=not show_progress)
for index, row in row_iter:
if not pd.isnull(index):
order = int(index)
if int(row.SampleID) not in withdrawn_ids:
keep_samples.extend([2 * order, 2 * order + 1])
metadata = {}
for k, v in row.items():
metadata[k] = None if pd.isnull(v) else str(v)
self.samples.add_individual(ploidy=2, metadata=metadata)
self.num_samples = len(keep_samples)
self.keep_index = np.array(keep_samples, dtype=int)
def read_bgen(filename: str, verbose: bool = False) -> Dict:
"""Wrapper of bgen_reader.read_bgen that checks if sample ids make sense."""
bgen = bgen_reader.read_bgen(filename, verbose=verbose)
if bgen['samples'][0] == 'sample_0':
print(
'WARNING: Sample ids in bgen file are generic. Trying to read the corresponding .sample file ...'
)
samples_filepath = filename[:-4] + 'sample'
if not path.exists(samples_filepath):
raise FileNotFoundError(f'{samples_filepath} does not exist.')
bgen = bgen_reader.read_bgen(filename,
verbose=verbose,
samples_filepath=samples_filepath)
bgen['samples'] = pd.read_csv(samples_filepath,
sep='\s+')['ID_2'][1:].to_numpy()
return bgen
def test_bgen_reader_convert_to_dosage():
folder = os.path.dirname(os.path.abspath(__file__)).encode()
filepath = os.path.join(folder, b"example.32bits.bgen")
bgen = read_bgen(filepath, verbose=False)
genotype = bgen['genotype']
dosage = convert_to_dosage(genotype, verbose=False)
assert_allclose(dosage[0, 1:3], array([1.93575854, 1.91558579]), rtol=1e-5)
def read(filepath,
size=50,
verbose=True,
metadata_file=True,
sample_file=None):
r"""Read a given BGEN file.
Parameters
----------
filepath : str
A BGEN file path.
size : float, optional
Chunk size in megabytes. Defaults to ``50``.
verbose : bool, optional
``True`` to show progress; ``False`` otherwise.
metadata_file : bool, str, optional
If ``True``, it will try to read the variants metadata from the
metadata file ``filepath + ".metadata"``. If this is not possible,
the variants metadata will be read from the BGEN file itself. If
``filepath + ".metadata"`` does not exist, it will try to create one
with the same name to speed up reads. If ``False``, variants metadata
will be read only from the BGEN file. If a file path is given instead,
it assumes that the specified metadata file is valid and readable and
therefore it will read variants metadata from that file only. Defaults
to ``True``.
sample_file : str, optional
A sample file in `GEN format <http://www.stats.ox.ac.uk/~marchini/software/gwas/file_format.html>`_.
If sample_file is provided, sample IDs are read from this file. Otherwise, it
reads from the BGEN file itself if present. Defaults to ``None``.
Returns
-------
variants : :class:`pandas.DataFrame`
Variant position, chromossomes, RSIDs, etc.
samples : :class:`pandas.DataFrame`
Sample identifications.
genotype : :class:`dask.array.Array`
Array of genotype references.
X : :class:`dask.array.Array`
Allele probabilities.
Note
----
Metadata files can speed up subsequent reads tremendously. But often the user does
not have write permission for the default metadata file location
``filepath + ".metadata"``. We thus provide the
:func:`limix.io.bgen.create_metadata_file` function for creating one at the
given path.
"""
from bgen_reader import read_bgen
print("Reading {}...".format(filepath))
return read_bgen(
filepath,
size=size,
verbose=verbose,
metadata_file=metadata_file,
sample_file=sample_file,
)
def test_read_bgem_interface():
filepath = example_filepath("haplotypes.bgen")
bgen = read_bgen(filepath, verbose=False)
assert isinstance(bgen, dict)
assert isinstance(bgen["variants"], dd.DataFrame)
assert isinstance(bgen["samples"], Series)
assert isinstance(bgen["genotype"], list)
assert isinstance(bgen["genotype"][0], Delayed)
def test_allele_frequency_interface():
filepath = example_filepath("complex.23bits.bgen")
with pytest.raises(ValueError):
bgen = read_bgen(filepath, verbose=False)
allele_expectation(bgen, 1)
bgen = read_bgen(filepath, verbose=False)
expec = allele_expectation(bgen, 3)
freq = allele_frequency(expec)
assert_allclose(freq, [1.33333333333, 1.0, 0.0])
freq = allele_frequency([[1.0, 0.0, 0.0], [2.0, 0.0, 0.0], [1.0, 1.0, 0.0],
[0.0, 2.0, 0.0]])
assert_allclose(freq, [1.33333333333, 1.0, 0.0])
with pytest.raises(ValueError):
allele_frequency([2, 3, 1])
def make_dosage(f):
bgen = bgen_reader.read_bgen(f,
size=200,
sample_file=samplefile,
verbose=False)
genotype = bgen['genotype'][:, mask, :].astype(dtype)
dosage = genotype[:, :, 1] + 2. * genotype[:, :, 2]
return dosage, bgen
def bgen_file_geno_lines(file, variant_mapping = None, force_colon = False, use_rsid=False, whitelist=None, skip_palindromic=False, liftover_conversion=None):
logging.log(9, "Processing bgen %s", file)
bgen = bgen_reader.read_bgen(file)
variants = bgen["variants"]
dict_mapping = variant_mapping is not None and type(variant_mapping) == dict
for variant in variants.itertuples():
if use_rsid:
varid = variant.rsid
else:
varid = variant.id
if force_colon:
varid = varid.replace("_", ":")
alleles = variant.allele_ids.split(",")
if len(alleles) > 2:
logging.info("variant %s is multiallelic, skipping", varid)
continue
allele_0, allele_1 = alleles[0], alleles[1]
if skip_palindromic and Genomics.is_palindromic(allele_0, allele_1):
continue
pos = variant.pos
chr = variant.chrom
if liftover_conversion:
chr_, pos_ = chr, pos
chr, pos = liftover_conversion(chr, pos)
if chr == "NA" or pos == "NA":
continue
if variant_mapping:
if dict_mapping:
if not varid in variant_mapping:
continue
else:
varid_ = varid
varid = variant_mapping[varid]
else:
raise RuntimeError("BGEN code doessn't support variant mapping through a method")
# subtlety: even though we replace the variant id,
# the alleles in the genotype might be swapped respect the variant in the mapping
# You should verify if you must match it
if whitelist and not varid in whitelist:
continue
v = bgen["genotype"][variant.Index].compute()
if v["phased"]:
d = numpy.apply_along_axis(lambda x: x[1] + x[3], 1, numpy.array(v["probs"], dtype=numpy.float))
else:
d = numpy.apply_along_axis(lambda x: x[1] + x[2] * 2, 1, numpy.array(v["probs"], dtype=numpy.float))
#e = bgen_reader.allele_expectation(bgen, variant.Index)
#d2 = bgen_reader.compute_dosage(e, alt=1)
yield (varid, chr, pos, allele_0, allele_1, numpy.mean(d)/2) + tuple(d)
def test_bgen_reader_without_metadata():
filepath = example_filepath("example.32bits.bgen")
bgen = read_bgen(filepath, verbose=False)
variants = bgen["variants"].compute()
samples = bgen["samples"]
assert "genotype" in bgen
assert_equal(variants.loc[7, "allele_ids"], "A,G")
n = samples.shape[0]
assert_equal(samples.loc[n - 1], "sample_500")
def test_bgen_samples_specify_samples_file():
data = read_bgen(
example_filepath("complex.23bits.bgen"),
samples_filepath=example_filepath("complex.sample"),
verbose=False,
)
samples = ["sample_0", "sample_1", "sample_2", "sample_3"]
samples = Series(samples, dtype=str, name="id")
assert all(data["samples"] == samples)
def run(path):
ct = 0
bgen = read_bgen(path, verbose=False)
n = len(bgen["genotype"])
print(f'Found {n} variants')
for i in tqdm.tqdm(range(n), total=n):
geno = bgen["genotype"][i].compute()
# geno['probs'] is (n_samples, n_genotypes), i.e. (486443, 3) for UKB
assert geno['probs'].ndim == 2
ct += geno['probs'].shape[0]
print(f'Number of entries read: {ct}')
def test_dosage_example_32bits():
filepath = example_filepath("example.32bits.bgen")
bgen = read_bgen(filepath, verbose=False)
e = allele_expectation(bgen, 5)
assert_allclose(e[7], [1.9556273911044997, 0.044372608895500334])
e = allele_expectation(bgen, 0)
assert all(isnan(e[0]))
e = allele_expectation(bgen, 0)
assert_equal(e.shape, (500, 2))
def test_bgen_reader_complex():
filepath = example_filepath("complex.23bits.bgen")
bgen = read_bgen(filepath, verbose=False)
variants = bgen["variants"].compute()
samples = bgen["samples"]
assert "genotype" in bgen
assert_equal(variants.loc[0, "chrom"], "01")
assert_equal(variants.loc[0, "id"], "")
assert_equal(variants.loc[0, "nalleles"], 2)
assert_equal(variants.loc[0, "allele_ids"], "A,G")
assert_equal(variants.loc[0, "pos"], 1)
assert_equal(variants.loc[0, "rsid"], "V1")
assert_equal(variants.loc[7, "chrom"], "01")
assert_equal(variants.loc[7, "id"], "")
assert_equal(variants.loc[7, "nalleles"], 7)
assert_equal(variants.loc[7, "allele_ids"], "A,G,GT,GTT,GTTT,GTTTT,GTTTTT")
assert_equal(variants.loc[7, "pos"], 8)
assert_equal(variants.loc[7, "rsid"], "M8")
n = variants.shape[0]
assert_equal(variants.loc[n - 1, "chrom"], "01")
assert_equal(variants.loc[n - 1, "id"], "")
assert_equal(variants.loc[n - 1, "nalleles"], 2)
assert_equal(variants.loc[n - 1, "allele_ids"], "A,G")
assert_equal(variants.loc[n - 1, "pos"], 10)
assert_equal(variants.loc[n - 1, "rsid"], "M10")
assert_equal(samples.loc[0], "sample_0")
assert_equal(samples.loc[3], "sample_3")
g = bgen["genotype"][0].compute()["probs"][0]
assert_allclose(g[:2], [1, 0])
assert isnan(g[2])
g = bgen["genotype"][0].compute()["probs"][1]
assert_allclose(g[:3], [1, 0, 0])
g = bgen["genotype"][-1].compute()["probs"][-1]
assert_allclose(g[:5], [0, 0, 0, 1, 0])
ploidy = bgen["genotype"][0].compute()["ploidy"]
assert_allclose(ploidy, [1, 2, 2, 2])
ploidy = bgen["genotype"][-1].compute()["ploidy"]
assert_allclose(ploidy, [4, 4, 4, 4])
nvariants = len(variants)
phased = [bgen["genotype"][i].compute()["phased"] for i in range(nvariants)]
phased = array(phased)
assert_equal(phased.dtype.name, "bool")
ideal = array([False, True, True, False, True, True, True, True, False, False])
assert array_equal(phased, ideal)
def process_sites(self, show_progress=False, max_sites=None):
bgen = bgen_reader.read_bgen(self.data_file, verbose=False)
num_alleles = np.array(bgen["variants"]["nalleles"])
position = np.array(bgen["variants"]["pos"])
rsid = np.array(bgen["variants"]["rsid"])
allele_id = np.array(bgen["variants"]["allele_ids"])
del bgen
bg = simplebgen.BgenReader(self.data_file)
N = 2 * bg.num_samples
for j in tqdm.tqdm(range(bg.num_variants)):
ancestral_state = self.get_ancestral_state(position[j])
if ancestral_state is not None:
alleles = allele_id[j].split(",")
if num_alleles[j] != 2 or ancestral_state not in alleles:
self.num_non_biallelic += 1
elif any(len(allele) != 1 for allele in alleles):
self.num_indels += 1
else:
P = bg.get_probabilities(j).astype(np.int8).reshape((N, 2))
# The probabilities for each site is a (num_diploids, 4) array,
# in the form (n0_a0, n0_a1, n1_a0, n1_a1). These are always zero
# or one for the different alleles. We first flatten this array so
# that it's (N, 2) and then generate the genotypes based on that.
genotypes = np.zeros(N, dtype=np.int8)
if ancestral_state == alleles[0]:
genotypes[P[:, 1] == 1] = 1
ref = alleles[0]
else:
genotypes[P[:, 0] == 1] = 1
ref = alleles[0]
alleles = alleles[::-1]
freq = np.sum(genotypes)
if freq == self.num_samples or freq == 0:
self.num_invariant += 1
elif freq == 1:
self.num_singletons += 1
elif freq == self.num_samples - 1:
self.num_nmo_tons += 1
else:
metadata = {"ID": rsid[j], "REF": ref}
self.samples.add_site(
position=float(position[j]),
genotypes=genotypes[self.keep_index],
alleles=alleles,
metadata=metadata)
if j == max_sites:
break
self.report()
def test_bgen_reader_variants_info():
filepath = example_filepath("example.32bits.bgen")
bgen = read_bgen(filepath, verbose=False)
variants = bgen["variants"]
samples = bgen["samples"]
assert "genotype" in bgen
variants = variants.compute()
assert_equal(variants.loc[0, "chrom"], "01")
assert_equal(variants.loc[0, "id"], "SNPID_2")
assert_equal(variants.loc[0, "nalleles"], 2)
assert_equal(variants.loc[0, "allele_ids"], "A,G")
assert_equal(variants.loc[0, "pos"], 2000)
assert_equal(variants.loc[0, "rsid"], "RSID_2")
assert_equal(variants.loc[7, "chrom"], "01")
assert_equal(variants.loc[7, "id"], "SNPID_9")
assert_equal(variants.loc[7, "nalleles"], 2)
assert_equal(variants.loc[7, "allele_ids"], "A,G")
assert_equal(variants.loc[7, "pos"], 9000)
assert_equal(variants.loc[7, "rsid"], "RSID_9")
n = variants.shape[0]
assert_equal(variants.loc[n - 1, "chrom"], "01")
assert_equal(variants.loc[n - 1, "id"], "SNPID_200")
assert_equal(variants.loc[n - 1, "nalleles"], 2)
assert_equal(variants.loc[n - 1, "allele_ids"], "A,G")
assert_equal(variants.loc[n - 1, "pos"], 100001)
assert_equal(variants.loc[n - 1, "rsid"], "RSID_200")
assert_equal(samples.loc[0], "sample_001")
assert_equal(samples.loc[7], "sample_008")
n = samples.shape[0]
assert_equal(samples.loc[n - 1], "sample_500")
g = bgen["genotype"][0].compute()["probs"]
assert all(isnan(g[0, :]))
g = bgen["genotype"][0].compute()["probs"]
a = [0.027802362811705648, 0.00863673794284387, 0.9635608992454505]
assert_allclose(g[1, :], a)
b = [
0.97970582847010945215516,
0.01947019668749305418287,
0.00082397484239749366197,
]
g = bgen["genotype"][1].compute()["probs"]
assert_allclose(g[2, :], b)
def check():
filename = sys.argv[1]
bgen = bgen_reader.read_bgen(filename, verbose=False)
num_variants = len(bgen["variants"])
num_samples = len(bgen["samples"])
br = simplebgen.BgenReader(filename)
assert br.num_variants == num_variants
assert br.num_samples == num_samples
for j in range(num_variants):
p1 = br.get_probabilities(j)
p2 = np.array(bgen["genotype"][j].compute())
np.testing.assert_equal(p1, p2)
print("all good")
def test_compute_dosage():
with example_files("example.32bits.bgen") as filepath:
bgen = read_bgen(filepath, verbose=False)
variant_idx = 2
e = allele_expectation(bgen, variant_idx)
dosage = compute_dosage(e)
assert_allclose(
dosage[:5],
[
0.015502935046214363,
0.9938354277968955,
1.9793395833064196,
0.9956054727070978,
1.978790270625332,
],
)
def test_bgen_reader_complex_sample_file():
bgen = read_bgen(
example_filepath("complex.23bits.bgen"),
samples_filepath=example_filepath("complex.sample"),
verbose=False,
)
variants = bgen["variants"].compute()
samples = bgen["samples"]
assert "genotype" in bgen
assert_equal(variants.loc[0, "chrom"], "01")
assert_equal(variants.loc[0, "id"], "")
assert_equal(variants.loc[0, "nalleles"], 2)
assert_equal(variants.loc[0, "allele_ids"], "A,G")
assert_equal(variants.loc[0, "pos"], 1)
assert_equal(variants.loc[0, "rsid"], "V1")
assert_equal(variants.loc[7, "chrom"], "01")
assert_equal(variants.loc[7, "id"], "")
assert_equal(variants.loc[7, "nalleles"], 7)
assert_equal(variants.loc[7, "allele_ids"], "A,G,GT,GTT,GTTT,GTTTT,GTTTTT")
assert_equal(variants.loc[7, "pos"], 8)
assert_equal(variants.loc[7, "rsid"], "M8")
n = variants.shape[0]
assert_equal(variants.loc[n - 1, "chrom"], "01")
assert_equal(variants.loc[n - 1, "id"], "")
assert_equal(variants.loc[n - 1, "nalleles"], 2)
assert_equal(variants.loc[n - 1, "allele_ids"], "A,G")
assert_equal(variants.loc[n - 1, "pos"], 10)
assert_equal(variants.loc[n - 1, "rsid"], "M10")
assert_equal(samples.loc[0], "sample_0")
assert_equal(samples.loc[3], "sample_3")
ploidy = bgen["genotype"][2].compute()["ploidy"]
missing = bgen["genotype"][2].compute()["missing"]
nvariants = len(variants)
phased = [bgen["genotype"][i].compute()["phased"] for i in range(nvariants)]
assert_allclose(ploidy, [1, 2, 2, 2])
assert_allclose(missing, [0, 0, 0, 0])
assert_allclose(phased, [0, 1, 1, 0, 1, 1, 1, 1, 0, 0])
def test_bgen_reader_file_notfound():
folder = os.path.dirname(os.path.abspath(__file__)).encode()
filepath = os.path.join(folder, b"example.33bits.bgen")
with pytest.raises(FileNotFoundError):
read_bgen(filepath, verbose=False)
from bgen_reader import read_bgen
if __name__ == '__main__':
bgen = read_bgen("example.bgen", verbose=False)
print(bgen['variants'].head())
print(bgen['samples'].head())
print(len(bgen['genotype']))
print(bgen['genotype'][0].compute())
