import os
from itertools import product
import matplotlib
matplotlib.use('AGG') # pylint: disable=
import numpy as np
import pandas
import pkg_resources
import pytest
from pybedtools import BedTool
from janggu.data import Bioseq
from janggu.data import Cover
from janggu.data import Transpose
from janggu.data import GenomicIndexer
from janggu.data import plotGenomeTrack
from janggu.data import LineTrack
from janggu.data import SeqTrack
from janggu.data import HeatTrack
def test_channel_last_first():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bwfile_ = os.path.join(data_path, "sample.bw")
cover = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
resolution=1,
binsize=200,
roi=bed_file,
store_whole_genome=True,
storage='ndarray')
assert cover.shape == (100, 200, 1, 1)
assert cover[0].shape == (1, 200, 1, 1)
cover1 = cover
cover = Transpose(Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
resolution=1,
binsize=200,
roi=bed_file,
store_whole_genome=True,
storage='ndarray'), axis=(0, 3, 2, 1))
assert cover.shape == (100, 1, 1, 200)
assert cover[0].shape == (1, 1, 1, 200)
np.testing.assert_equal(cover1[0], np.transpose(cover[0], (0, 3, 2, 1)))
def test_cover_roi_binsize_padding(tmpdir):
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, 'sample_equalsize.bed')
print(pandas.read_csv(bed_file,
sep='\t', header=None,
names=['chrom', 'start', 'end',
'name', 'score', 'strand']))
roi_file = os.path.join(data_path, "sample.bed")
roi = pandas.read_csv(roi_file,
sep='\t', header=None,
names=['chrom', 'start', 'end',
'name', 'score', 'strand'])
roi.end.iloc[0] += 12
roi.end.iloc[1] += 111
print(roi)
with pytest.raises(ValueError):
# error due to binsize not being a multiple of resolution
Cover.create_from_bed('test',
bedfiles=bed_file,
roi=roi, binsize=30,
stepsize=30,
store_whole_genome=True,
cache=False, resolution=7)
with pytest.raises(ValueError):
# interval starts must align with resolution intervals
rroi = roi.copy()
rroi.start += 1
Cover.create_from_bed('test',
bedfiles=bed_file,
roi=rroi, binsize=30,
stepsize=30,
store_whole_genome=True,
cache=False, resolution=30)
for swg, store in product([True, False], ['ndarray', 'sparse']):
cov = Cover.create_from_bed('test',
bedfiles=bed_file,
roi=roi, binsize=300,
stepsize=300,
store_whole_genome=swg,
storage=store,
cache=False, resolution=10)
assert len(cov) == 68
assert cov.shape == (68, 30, 1, 1)
[c for c in cov]
for swg, store in product([True, False], ['ndarray', 'sparse']):
cov = Cover.create_from_bed('test',
bedfiles=bed_file,
roi=roi, binsize=300,
stepsize=300,
store_whole_genome=swg,
cache=False, resolution=3)
assert len(cov) == 68
assert cov.shape == (68, 100, 1, 1)
[c for c in cov]
for swg, store in product([True, False], ['ndarray', 'sparse']):
cov = Cover.create_from_bed('test',
bedfiles=bed_file,
roi=roi, binsize=300,
stepsize=300,
store_whole_genome=swg,
storage=store,
cache=False, resolution=3)
assert len(cov) == 68
assert cov.shape == (68, 100, 1, 1)
[c for c in cov]
for swg, store in product([True, False], ['ndarray', 'sparse']):
cov = Cover.create_from_bed('test',
bedfiles=bed_file,
roi=roi, binsize=300,
stepsize=300,
store_whole_genome=swg,
storage=store,
cache=False, resolution=3)
assert len(cov) == 68
assert cov.shape == (68, 100, 1, 1)
[c for c in cov]
for swg, store in product([True, False], ['ndarray', 'sparse']):
cov = Cover.create_from_bed('test',
bedfiles=bed_file,
roi=roi, binsize=300,
stepsize=300,
store_whole_genome=swg,
storage=store,
cache=False, resolution=100)
assert len(cov) == 68
assert cov.shape == (68, 3, 1, 1)
[c for c in cov]
for swg, store in product([True, False], ['ndarray', 'sparse']):
cov = Cover.create_from_bed('test',
bedfiles=bed_file,
roi=roi, binsize=300,
stepsize=300,
store_whole_genome=swg,
cache=False, resolution=100,
storage=store,
zero_padding=False)
assert len(cov) == 66
assert cov.shape == (66, 3, 1, 1)
[c for c in cov]
bwfile_ = os.path.join(data_path, "sample.bw")
for swg, store in product([True, False], ['ndarray', 'sparse']):
cover = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
resolution=100,
binsize=300,
roi=roi,
storage=store,
store_whole_genome=swg)
assert len(cover) == 68
assert cover.shape == (68, 3, 1, 1)
[c for c in cover]
for swg, store in product([True, False], ['ndarray', 'sparse']):
cover = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
resolution=100,
binsize=300,
roi=roi, zero_padding=False,
storage=store,
store_whole_genome=swg)
assert len(cover) == 66
assert cover.shape == (66, 3, 1, 1)
[c for c in cover]
bamfile_ = os.path.join(data_path, "sample.bam")
for swg, store in product([True, False], ['ndarray', 'sparse']):
cover = Cover.create_from_bam(
'test',
bamfile_,
resolution=100,
binsize=300,
roi=roi,
stranded=False,
storage=store,
store_whole_genome=swg)
assert len(cover) == 68
assert cover.shape == (68, 3, 1, 1)
[c for c in cover]
for swg, store in product([True, False], ['ndarray', 'sparse']):
cover = Cover.create_from_bam(
'test',
bamfile_,
resolution=100,
binsize=300,
roi=roi, zero_padding=False,
stranded=False,
storage=store,
store_whole_genome=swg)
assert len(cover) == 66
assert cover.shape == (66, 3, 1, 1)
[c for c in cover]
def test_cover_export_bigwig(tmpdir):
path = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bwfile_ = os.path.join(data_path, "sample.bw")
for resolution in [1, 50]:
for storage in [True, False]:
print('resolution=', resolution)
print('store_whole_genome', storage)
cover = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
resolution=resolution,
binsize=200,
roi=bed_file,
store_whole_genome=storage,
storage='ndarray')
cover.export_to_bigwig(output_dir=path)
cov2 = Cover.create_from_bigwig('test',
bigwigfiles='{path}/{name}.{sample}.bigwig'.format(
path=path, name=cover.name,
sample=cover.conditions[0]),
resolution=resolution,
binsize=200,
roi=bed_file,
store_whole_genome=storage,
storage='ndarray')
assert cover.shape == (100, 200 // resolution, 1, 1)
assert cover.shape == cov2.shape
np.testing.assert_allclose(cover[:].sum(), 1044.0 / resolution)
np.testing.assert_allclose(cov2[:].sum(), 1044.0 / resolution)
def test_bam_genomic_interval_access():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bamfile_ = os.path.join(data_path, "sample.bam")
for reso, shift, storage in product([1, 50], [0, 1], [True, False]):
cover = Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=bed_file,
flank=0,
storage='ndarray',
store_whole_genome=storage,
resolution=reso)
for i in range(len(cover)):
print('storage :',storage,'/ resolution :',reso,'/ shift :',shift)
np.testing.assert_equal(np.repeat(cover[i],
cover.garray.resolution,
axis=1), cover[cover.gindexer[i]])
chrom, start, end, strand = cover.gindexer[i].chrom, \
cover.gindexer[i].start, \
cover.gindexer[i].end, \
cover.gindexer[i].strand
np.testing.assert_equal(np.repeat(cover[i],
cover.garray.resolution, axis=1),
cover[chrom, start, end, strand])
np.testing.assert_equal(cover[chrom, start, end, strand],
cover[chrom, start-1, end+1, strand][:, 1:-1, :, :])
if shift != 0:
start += shift * reso
end += shift * reso
if strand != '-':
gicov = cover[chrom, start, end, strand][:, :(-shift*reso),:,:]
np.testing.assert_equal(cover[i][:, shift:,:, :],
gicov.reshape((1, gicov.shape[1]//reso, reso, 2, 1))[:, :, 0, :, :])
else:
gicov = cover[chrom, start, end, strand][:, (shift*reso):,:,:]
np.testing.assert_equal(cover[i][:, :-shift,:, :],
gicov.reshape((1, gicov.shape[1]//reso, reso, 2, 1))[:, :, 0, :, :])
def test_bigwig_genomic_interval_access():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bamfile_ = os.path.join(data_path, "sample.bw")
for reso, shift, storage in product([1, 50], [0, 1], [True, False]):
cover = Cover.create_from_bigwig(
'test',
bigwigfiles=bamfile_,
roi=bed_file,
flank=0,
storage='ndarray',
store_whole_genome=storage,
resolution=reso)
for i in range(len(cover)):
print('storage :',storage,'/ resolution :',reso,'/ shift :',shift)
np.testing.assert_equal(np.repeat(cover[i],
cover.garray.resolution,
axis=1), cover[cover.gindexer[i]])
chrom, start, end, strand = cover.gindexer[i].chrom, \
cover.gindexer[i].start, \
cover.gindexer[i].end, \
cover.gindexer[i].strand
np.testing.assert_equal(np.repeat(cover[i],
cover.garray.resolution, axis=1),
cover[chrom, start, end, strand])
if shift != 0:
start += shift * reso
end += shift * reso
if strand != '-':
gicov = cover[chrom, start, end, strand][:, :(-shift*reso),:,:]
np.testing.assert_equal(cover[i][:, shift:,:, :],
gicov.reshape((1, gicov.shape[1]//reso, reso, 1, 1))[:, :, 0, :, :])
else:
gicov = cover[chrom, start, end, strand][:, (shift*reso):,:,:]
np.testing.assert_equal(cover[i][:, :-shift,:, :],
gicov.reshape((1, gicov.shape[1]//reso, reso, 1, 1))[:, :, 0, :, :])
def test_bed_genomic_interval_access():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bamfile_ = os.path.join(data_path, "sample.bed")
for reso, shift, storage in product([1, 50], [0, 1], [True, False]):
cover = Cover.create_from_bed(
'test',
bedfiles=bamfile_,
roi=bed_file,
flank=0,
storage='ndarray',
store_whole_genome=storage,
resolution=reso)
for i in range(len(cover)):
print('storage :',storage,'/ resolution :',reso,'/ shift :',shift)
np.testing.assert_equal(np.repeat(cover[i],
cover.garray.resolution,
axis=1), cover[cover.gindexer[i]])
chrom, start, end, strand = cover.gindexer[i].chrom, \
cover.gindexer[i].start, \
cover.gindexer[i].end, \
cover.gindexer[i].strand
np.testing.assert_equal(np.repeat(cover[i],
cover.garray.resolution, axis=1),
cover[chrom, start, end, strand])
if shift != 0:
start += shift * reso
end += shift * reso
if strand != '-':
gicov = cover[chrom, start, end, strand][:, :(-shift*reso),:,:]
np.testing.assert_equal(cover[i][:, shift:,:, :],
gicov.reshape((1, gicov.shape[1]//reso, reso, 1, 1))[:, :, 0, :, :])
else:
gicov = cover[chrom, start, end, strand][:, (shift*reso):,:,:]
np.testing.assert_equal(cover[i][:, :-shift,:, :],
gicov.reshape((1, gicov.shape[1]//reso, reso, 1, 1))[:, :, 0, :, :])
def test_bam_inferred_binsize():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "positive.bed")
bamfile_ = os.path.join(data_path, "sample.bam")
cover = Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=bed_file,
flank=0,
storage='ndarray')
assert len(cover) == 25
assert cover.shape == (25, 200, 2, 1)
def test_bigwig_inferred_binsize():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "positive.bed")
bwfile_ = os.path.join(data_path, "sample.bw")
cover = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
resolution=1,
roi=bed_file,
storage='ndarray')
assert len(cover) == 25
assert cover.shape == (25, 200, 1, 1)
def test_bed_unsync_roi_targets():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "positive.bed")
bed_shift_file = os.path.join(data_path, "positive_shift.bed")
cover = Cover.create_from_bed(
'test',
bedfiles=bed_shift_file,
roi=bed_file,
resolution=None,
storage='ndarray')
assert len(cover) == 25
assert cover.shape == (25, 1, 1, 1)
assert cover[:].sum() == 1
cover = Cover.create_from_bed(
'test',
bedfiles=bed_shift_file,
roi=bed_file,
resolution=50,
storage='ndarray')
assert len(cover) == 25
assert cover.shape == (25, 4, 1, 1)
assert cover[:].sum() == 1
cover = Cover.create_from_bed(
'test',
bedfiles=bed_shift_file,
roi=bed_file,
resolution=50,
store_whole_genome=True,
storage='ndarray')
assert len(cover) == 25
assert cover.shape == (25, 4, 1, 1)
assert cover[:].sum() == 1
cover = Cover.create_from_bed(
'test',
bedfiles=bed_shift_file,
roi=bed_file,
resolution=1,
store_whole_genome=False,
storage='ndarray')
assert len(cover) == 25
assert cover.shape == (25, 200, 1, 1)
assert cover[0].sum() == 49
cover = Cover.create_from_bed(
'test',
bedfiles=bed_shift_file,
roi=bed_file,
resolution=1,
store_whole_genome=True,
storage='ndarray')
assert len(cover) == 25
assert cover.shape == (25, 200, 1, 1)
assert cover[:].sum() == 49
cover = Cover.create_from_bed(
'test',
bedfiles=bed_shift_file,
roi=bed_file,
resolution=1,
store_whole_genome=True,
storage='ndarray', minoverlap=.5)
assert len(cover) == 25
assert cover.shape == (25, 200, 1, 1)
assert cover[:].sum() == 0
# check bed file loading without roi
cover_ = Cover.create_from_bed(
'test',
bedfiles=bed_shift_file,
roi=None,
resolution=1,
store_whole_genome=True,
storage='ndarray', minoverlap=.5)
cover_.gindexer = cover.gindexer
assert len(cover) == 25
assert cover.shape == (25, 200, 1, 1)
assert cover[:].sum() == 0
def test_bed_inferred_binsize():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "positive.bed")
cover = Cover.create_from_bed(
'test',
bedfiles=bed_file,
roi=bed_file,
resolution=1,
storage='ndarray')
assert len(cover) == 25
assert cover.shape == (25, 200, 1, 1)
bed_file = os.path.join(data_path, "positive_gap.bed")
cover = Cover.create_from_bed(
'test',
bedfiles=bed_file,
roi=bed_file,
resolution=1,
store_whole_genome=True,
storage='ndarray')
assert len(cover) == 2
assert cover.shape == (2, 50, 1, 1)
def test_bed_overreaching_ends_whole_genome():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "bed_test.bed")
for store in ['ndarray', 'sparse']:
print(store)
cover = Cover.create_from_bed(
'test',
bedfiles=bed_file,
roi=bed_file,
binsize=2,
flank=20,
resolution=1,
store_whole_genome=True,
storage=store)
assert len(cover) == 9
assert cover.shape == (9, 2+2*20, 1, 1)
np.testing.assert_equal(cover[0].sum(), 18)
np.testing.assert_equal(cover[:].sum(), 9*18)
def test_bed_overreaching_ends_part_genome():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "bed_test.bed")
for store in ['ndarray', 'sparse']:
print(store)
cover = Cover.create_from_bed(
'test',
bedfiles=bed_file,
roi=bed_file,
binsize=2,
flank=2,
resolution=1,
store_whole_genome=False,
storage=store)
assert len(cover) == 9
assert cover.shape == (9, 2+2*2, 1, 1)
np.testing.assert_equal(cover[0].sum(), 4)
np.testing.assert_equal(cover[:].sum(), 6*7 + 8)
def test_bed_store_whole_genome_option():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "positive_shift.bed")
cover1 = Cover.create_from_bed(
'test',
bedfiles=bed_file,
roi=bed_file,
store_whole_genome=True,
storage='ndarray')
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bed_file,
roi=bed_file,
store_whole_genome=False,
storage='ndarray')
assert len(cover1) == 1
assert len(cover2) == len(cover1)
assert cover1.shape == (1, 49, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], np.ones(cover1.shape))
np.testing.assert_equal(cover2[:], np.ones(cover1.shape))
def test_bed_store_whole_genome_option_dataframe(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
# as pd.dataframe
roi = pandas.read_csv(bed_file,
sep='\t', header=None,
names=['chrom', 'start', 'end',
'name', 'score', 'strand'])
print(roi.head())
cover1 = Cover.create_from_bed(
'test',
bedfiles=bed_file,
roi=roi,
binsize=200, stepsize=200,
store_whole_genome=True,
cache=False,
storage='ndarray')
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bed_file,
roi=roi,
binsize=200, stepsize=200,
store_whole_genome=False,
cache=True,
storage='ndarray')
print(cover1.gindexer[0])
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
np.testing.assert_equal(cover1[:], np.ones(cover1.shape))
# as bedtool
roi = BedTool(bed_file)
print(roi)
cover1 = Cover.create_from_bed(
'test',
bedfiles=bed_file,
roi=roi,
binsize=200, stepsize=200,
store_whole_genome=True,
storage='ndarray')
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bed_file,
roi=roi,
binsize=200, stepsize=200,
store_whole_genome=False,
cache=True,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
np.testing.assert_equal(cover1[:], np.ones(cover1.shape))
# as interval list
roi = [iv for iv in BedTool(bed_file)]
print(roi)
cover1 = Cover.create_from_bed(
'test',
bedfiles=bed_file,
roi=roi,
binsize=200, stepsize=200,
store_whole_genome=True,
storage='ndarray')
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bed_file,
roi=roi,
binsize=200, stepsize=200,
store_whole_genome=False,
cache=True,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
np.testing.assert_equal(cover1[:], np.ones(cover1.shape))
def test_bigwig_store_whole_genome_option():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bwfile_ = os.path.join(data_path, "sample.bw")
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=bed_file,
store_whole_genome=True,
binsize=200, stepsize=200,
storage='ndarray')
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile_,
roi=bed_file,
store_whole_genome=False,
binsize=200, stepsize=200,
storage='ndarray')
cover3 = Cover.create_from_bigwig(
'test3',
bigwigfiles=bwfile_,
roi=bed_file,
store_whole_genome=False,
binsize=200, stepsize=200,
nan_to_num=False,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
assert cover1[:].sum() == 1044.0
assert cover3[:].sum() == 1044.0
def test_bigwig_store_whole_genome_option_dataframe(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bwfile_ = os.path.join(data_path, "sample.bw")
# as dataframe
roi = pandas.read_csv(bed_file,
sep='\t', header=None, names=['chrom', 'start', 'end', 'name', 'score', 'strand'])
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=roi,
store_whole_genome=True,
binsize=200, stepsize=200,
storage='ndarray')
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile_,
roi=roi,
store_whole_genome=False,
binsize=200, stepsize=200,
cache=True,
storage='ndarray')
cover3 = Cover.create_from_bigwig(
'test3',
bigwigfiles=bwfile_,
roi=roi,
store_whole_genome=False,
binsize=200, stepsize=200,
nan_to_num=False,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
assert cover1[:].sum() == 1044.0
assert cover3[:].sum() == 1044.0
# as bedtool
roi = BedTool(bed_file)
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=roi,
store_whole_genome=True,
binsize=200, stepsize=200,
storage='ndarray')
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile_,
roi=roi,
store_whole_genome=False,
binsize=200, stepsize=200,
cache=True,
storage='ndarray')
cover3 = Cover.create_from_bigwig(
'test3',
bigwigfiles=bwfile_,
roi=roi,
store_whole_genome=False,
binsize=200, stepsize=200,
nan_to_num=False,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
assert cover1[:].sum() == 1044.0
assert cover3[:].sum() == 1044.0
# as list of intervals
roi = [iv for iv in roi]
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=roi,
store_whole_genome=True,
binsize=200, stepsize=200,
storage='ndarray')
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile_,
roi=roi,
store_whole_genome=False,
binsize=200, stepsize=200,
cache=True,
storage='ndarray')
cover3 = Cover.create_from_bigwig(
'test3',
bigwigfiles=bwfile_,
roi=roi,
store_whole_genome=False,
binsize=200, stepsize=200,
nan_to_num=False,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
assert cover1[:].sum() == 1044.0
assert cover3[:].sum() == 1044.0
def test_bam_store_whole_genome_option_dataframe(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bamfile_ = os.path.join(data_path, "sample.bam")
# as dataframe
roi = pandas.read_csv(bed_file,
sep='\t', header=None, names=['chrom', 'start', 'end', 'name', 'score', 'strand'])
cover1 = Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=roi,
store_whole_genome=True,
binsize=200, stepsize=200,
storage='ndarray')
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bamfile_,
roi=roi,
store_whole_genome=False,
binsize=200, stepsize=200,
cache=True,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 2, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
assert cover1[:].sum() == 29.
# as bedtool
roi = BedTool(bed_file)
cover1 = Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=roi,
store_whole_genome=True,
binsize=200, stepsize=200,
storage='ndarray')
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bamfile_,
roi=roi,
store_whole_genome=False,
binsize=200, stepsize=200,
cache=True,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 2, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
assert cover1[:].sum() == 29.
# as list of intervals
roi = [iv for iv in roi]
cover1 = Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=roi,
store_whole_genome=True,
binsize=200, stepsize=200,
storage='ndarray')
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bamfile_,
roi=roi,
store_whole_genome=False,
binsize=200, stepsize=200,
cache=True,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 2, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
assert cover1[:].sum() == 29.
def test_bam_store_whole_genome_option():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bamfile_ = os.path.join(data_path, "sample.bam")
cover1 = Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=bed_file,
store_whole_genome=True,
binsize=200, stepsize=200,
storage='ndarray')
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bamfile_,
roi=bed_file,
store_whole_genome=False,
binsize=200, stepsize=200,
storage='ndarray')
assert len(cover1) == 100
assert len(cover2) == len(cover1)
assert cover1.shape == (100, 200, 2, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
assert cover1[:].sum() == 29.
def test_cover_from_bam_sanity():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bamfile_ = os.path.join(data_path, "sample.bam")
cover = Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=bed_file,
binsize=200, stepsize=200,
flank=0,
storage='ndarray')
cover[0]
with pytest.raises(IndexError):
# not interable
cover[1.2]
cov2 = Cover.create_from_bam(
'test',
bamfiles=bamfile_,
storage='ndarray',
store_whole_genome=True)
assert len(cover.gindexer) == len(cover.garray.handle['data'])
assert len(cov2.garray.handle) != len(cover.garray.handle['data'])
with pytest.raises(Exception):
# name must be a string
Cover.create_from_bam(
1.2,
bamfiles=bamfile_,
roi=bed_file,
binsize=1, stepsize=1,
storage='ndarray')
with pytest.raises(Exception):
# bamfile does not exist
Cover.create_from_bam(
'test',
bamfiles="",
roi=bed_file,
binsize=1, stepsize=1,
flank=-1,
storage='ndarray')
with pytest.raises(Exception):
# bamfile does not exist
Cover.create_from_bam(
'test',
bamfiles=[],
roi=bed_file,
binsize=1, stepsize=1,
flank=-1,
storage='ndarray')
with pytest.raises(Exception):
Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=bed_file,
binsize=1, stepsize=1,
flank=-1,
storage='ndarray')
with pytest.raises(Exception):
Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=bed_file,
binsize=1, stepsize=-1,
flank=0,
storage='ndarray')
with pytest.raises(Exception):
Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=bed_file,
binsize=-1, stepsize=1,
flank=0,
storage='ndarray')
with pytest.warns(FutureWarning):
Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=bed_file,
binsize=200, stepsize=200,
storage='ndarray',
overwrite=True)
with pytest.warns(FutureWarning):
Cover.create_from_bam(
'test',
bamfiles=bamfile_,
roi=bed_file,
binsize=200, stepsize=200,
storage='ndarray',
datatags=['asdf'])
def test_cover_from_bigwig_sanity():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "sample.bed")
bwfile_ = os.path.join(data_path, "sample.bw")
cover = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=50,
resolution=50,
flank=0,
storage='ndarray')
cover[0]
assert len(cover.gindexer) == 394
assert len(cover.garray.handle['data']) == 394
cover = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=50,
resolution=50,
flank=0,
storage='ndarray',
store_whole_genome=True)
cover[0]
assert len(cover.gindexer) == 394
assert len(cover.garray.handle) == 2
cov2 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
resolution=7,
storage='ndarray',
store_whole_genome=True)
assert len(cov2.garray.handle) == 2
assert cov2['chr1', 100, 200].shape == (1, 100, 1, 1)
with pytest.raises(Exception):
cov2.shape
with pytest.raises(Exception):
cov2[0]
with pytest.raises(Exception):
# name must be a string
Cover.create_from_bigwig(
1.2,
bigwigfiles=bwfile_,
roi=bed_file,
binsize=1, stepsize=1,
storage='ndarray')
with pytest.raises(Exception):
Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=bed_file,
binsize=1, stepsize=1,
flank=-1,
storage='ndarray')
with pytest.raises(Exception):
Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=bed_file,
binsize=1, stepsize=-1,
flank=0,
storage='ndarray')
with pytest.raises(Exception):
Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=bed_file,
binsize=-1, stepsize=1,
flank=0,
storage='ndarray')
with pytest.warns(FutureWarning):
Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=200,
flank=0,
storage='ndarray',
overwrite=True)
with pytest.warns(FutureWarning):
Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=200,
storage='ndarray',
datatags=['asdf'])
def test_cover_from_bed_sanity():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, 'sample.bed')
bwfile_ = os.path.join(data_path, "scored_sample.bed")
cover = Cover.create_from_bed(
'test',
bedfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=50,
resolution=50,
flank=0,
storage='ndarray')
cover[0]
Cover.create_from_bed(
'test',
bedfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=50,
resolution=50,
storage='ndarray')
with pytest.raises(Exception):
# name must be a string
Cover.create_from_bed(
1.2,
bedfiles=bwfile_,
roi=bed_file,
binsize=1, stepsize=1,
storage='ndarray')
with pytest.raises(Exception):
Cover.create_from_bed(
'test',
bedfiles=bwfile_,
roi=bed_file,
binsize=1, stepsize=1,
flank=-1,
storage='ndarray')
with pytest.raises(Exception):
Cover.create_from_bed(
'test',
bedfiles=bwfile_,
roi=bed_file,
binsize=1, stepsize=-1,
flank=0,
storage='ndarray')
with pytest.raises(Exception):
Cover.create_from_bed(
'test',
bedfiles=bwfile_,
roi=bed_file,
binsize=-1, stepsize=1,
flank=0,
storage='ndarray')
with pytest.raises(Exception):
csvfile = os.path.join(data_path, 'ctcf_sample.csv')
# must be a bed file
Cover.create_from_bed(
'test',
bedfiles=csvfile,
roi=bed_file,
binsize=1, stepsize=1,
storage='ndarray')
with pytest.warns(FutureWarning):
Cover.create_from_bed(
'test',
bedfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=200,
flank=0,
storage='ndarray',
overwrite=True)
with pytest.warns(FutureWarning):
Cover.create_from_bed(
'test',
bedfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=200,
storage='ndarray',
datatags=['asdf'])
def test_cover_bam_unstranded():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bamfile_ = os.path.join(data_path, "sample.bam")
gsfile_ = os.path.join(data_path, 'sample.chrom.sizes')
content = pandas.read_csv(gsfile_, sep='\t', names=['chr', 'length'],
index_col='chr')
gsize = content.to_dict()['length']
bed_file = os.path.join(data_path, "sample.bed")
cover = Cover.create_from_bam(
"yeast_I_II_III.bam",
bamfiles=bamfile_,
roi=bed_file,
binsize=200, stepsize=200,
genomesize=gsize,
stranded=False)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 200, 1, 1))
# the region is read relative to the forward strand
# read on the reverse strand
val = np.where(cover[4] == 1)
np.testing.assert_equal(cover[4].sum(), 1.)
np.testing.assert_equal(val[1][0], 179) # pos
# two reads on the forward strand
val = np.where(cover[13] == 1)
np.testing.assert_equal(cover[13].sum(), 2.)
np.testing.assert_equal(val[1], np.asarray([162, 178])) # pos
# the region is read relative to the reverse strand
# for index 50
# read on the reverse strand
val = np.where(cover[52] == 1)
np.testing.assert_equal(cover[52].sum(), 2.)
np.testing.assert_equal(val[1], np.asarray([9, 89])) # pos
# two reads on the forward strand
val = np.where(cover[96] == 1)
np.testing.assert_equal(cover[96].sum(), 1.)
np.testing.assert_equal(val[1], np.asarray([25])) # pos
def test_cover_bam_paired_5pend():
# sample2.bam contains paired end examples,
# unmapped examples, unmapped mate and low quality example
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bamfile_ = os.path.join(data_path, "sample2.bam")
cover = Cover.create_from_bam(
"yeast_I_II_III.bam",
bamfiles=bamfile_,
stranded=False,
pairedend='5pend',
min_mapq=30,
store_whole_genome=True)
assert cover.garray.handle['ref'].sum() == 4, cover.garray.handle['ref']
# the read starts at index 6 and tlen is 39
assert cover.garray.handle['ref'][6, 0, 0] == 1
# another read maps to index 24
assert cover.garray.handle['ref'][24, 0, 0] == 1
def test_cover_bam_paired_midpoint():
# sample2.bam contains paired end examples,
# unmapped examples, unmapped mate and low quality example
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bamfile_ = os.path.join(data_path, "sample2.bam")
cover = Cover.create_from_bam(
"yeast_I_II_III.bam",
bamfiles=bamfile_,
stranded=False,
pairedend='midpoint',
min_mapq=30,
store_whole_genome=True)
assert cover.garray.handle['ref'].sum() == 2, cover.garray.handle['ref']
print(cover.garray.handle['ref'])
# the read starts at index 6 and tlen is 39
assert cover.garray.handle['ref'][6 + 39//2, 0, 0] == 1
# another read maps to index 34
assert cover.garray.handle['ref'][34, 0, 0] == 1
def test_cover_bam_list(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bamfile_ = os.path.join(data_path, "sample.bam")
bed_file = os.path.join(data_path, "sample.bed")
for store in ['ndarray', 'hdf5', 'sparse']:
# base pair binsize
cover = Cover.create_from_bam(
"yeast_I_II_III.bam",
bamfiles=[bamfile_],
roi=bed_file,
conditions=['condition2'],
normalizer='tpm',
binsize=200, stepsize=200)
def test_cover_bam(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bamfile_ = os.path.join(data_path, "sample.bam")
gsfile_ = os.path.join(data_path, 'sample.chrom.sizes')
content = pandas.read_csv(gsfile_, sep='\t', names=['chr', 'length'],
index_col='chr')
gsize = content.to_dict()['length']
bed_file = os.path.join(data_path, "sample.bed")
for store in ['ndarray', 'hdf5', 'sparse']:
# base pair binsize
cover = Cover.create_from_bam(
"yeast_I_II_III.bam",
bamfiles=bamfile_,
roi=bed_file,
binsize=200, stepsize=200,
genomesize=gsize,
storage=store, cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 200, 2, 1))
# the region is read relative to the forward strand
# read on the reverse strand
val = np.where(cover[4] == 1)
np.testing.assert_equal(cover[4].sum(), 1.)
np.testing.assert_equal(val[1][0], 179) # pos
np.testing.assert_equal(val[2][0], 1) # strand
# two reads on the forward strand
val = np.where(cover[13] == 1)
np.testing.assert_equal(cover[13].sum(), 2.)
np.testing.assert_equal(val[1], np.asarray([162, 178])) # pos
np.testing.assert_equal(val[2], np.asarray([0, 0])) # strand
# the region is read relative to the reverse strand
# for index 50
# read on the reverse strand
val = np.where(cover[52] == 1)
np.testing.assert_equal(cover[52].sum(), 2.)
np.testing.assert_equal(val[1], np.asarray([9, 89])) # pos
np.testing.assert_equal(val[2], np.asarray([0, 0])) # strand
# two reads on the forward strand
val = np.where(cover[96] == 1)
np.testing.assert_equal(cover[96].sum(), 1.)
np.testing.assert_equal(val[1], np.asarray([25])) # pos
np.testing.assert_equal(val[2], np.asarray([1])) # strand
def test_load_bam_resolution10(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bamfile_ = os.path.join(data_path, "sample.bam")
gsfile_ = os.path.join(data_path, 'sample.chrom.sizes')
content = pandas.read_csv(gsfile_, sep='\t', names=['chr', 'length'],
index_col='chr')
gsize = content.to_dict()['length']
bed_file = os.path.join(data_path, "sample.bed")
for store, store_genome in product(['ndarray', 'hdf5', 'sparse'], [True, False]):
# base pair binsize
cover = Cover.create_from_bam(
"yeast_I_II_III.bam",
bamfiles=bamfile_,
roi=bed_file,
binsize=200, stepsize=200,
genomesize=gsize,
resolution=10,
store_whole_genome=store_genome,
storage=store, cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 20, 2, 1))
# the region is read relative to the forward strand
# read on the reverse strand
val = np.where(cover[4] == 1)
np.testing.assert_equal(cover[4].sum(), 1.)
np.testing.assert_equal(val[1][0], 17) # pos
np.testing.assert_equal(val[2][0], 1) # strand
# two reads on the forward strand
val = np.where(cover[13] == 1)
np.testing.assert_equal(cover[13].sum(), 2.)
np.testing.assert_equal(val[1], np.asarray([16, 17])) # pos
np.testing.assert_equal(val[2], np.asarray([0, 0])) # strand
# the region is read relative to the reverse strand
# for index 50
# read on the reverse strand
val = np.where(cover[52] == 1)
np.testing.assert_equal(cover[52].sum(), 2.)
np.testing.assert_equal(val[1], np.asarray([0, 8])) # pos
np.testing.assert_equal(val[2], np.asarray([0, 0])) # strand
# two reads on the forward strand
val = np.where(cover[96] == 1)
np.testing.assert_equal(cover[96].sum(), 1.)
np.testing.assert_equal(val[1], np.asarray([2])) # pos
np.testing.assert_equal(val[2], np.asarray([1])) # strand
def test_load_bam_resolutionNone(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bamfile_ = os.path.join(data_path, "sample.bam")
gsfile_ = os.path.join(data_path, 'sample.chrom.sizes')
content = pandas.read_csv(gsfile_, sep='\t', names=['chr', 'length'],
index_col='chr')
gsize = content.to_dict()['length']
bed_file = os.path.join(data_path, "sample.bed")
for store in ['ndarray', 'hdf5', 'sparse']:
# base pair binsize
cover1 = Cover.create_from_bam(
"yeast_I_II_III.bam",
bamfiles=bamfile_,
roi=bed_file,
binsize=200, stepsize=200,
genomesize=gsize,
resolution=1,
storage=store, cache=True)
cover = Cover.create_from_bam(
"yeast_I_II_III.bam",
bamfiles=bamfile_,
roi=bed_file,
binsize=200, stepsize=200,
genomesize=gsize,
resolution=None,
storage=store, cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 2, 1))
np.testing.assert_equal(cover1[:].sum(axis=1), cover[:].sum(axis=1))
def test_load_cover_bigwig_default(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bwfile_ = os.path.join(data_path, "sample.bw")
gsfile_ = os.path.join(data_path, 'sample.chrom.sizes')
gsize = pandas.read_csv(gsfile_, sep='\t', names=['chr', 'length'],
index_col='chr').to_dict()['length']
bed_file = os.path.join(data_path, "sample.bed")
for store in ['ndarray', 'hdf5', 'sparse']:
# base pair binsize
print(store)
cover = Cover.create_from_bigwig(
"cov",
bigwigfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=200,
genomesize=gsize,
storage=store,
store_whole_genome=True,
cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 200, 1, 1))
# there is one read in the region
np.testing.assert_allclose(cover[4].sum(), 36.)
np.testing.assert_allclose(cover[52].sum(), 2*36.)
cover = Cover.create_from_bigwig(
"cov",
bigwigfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=200,
genomesize=gsize,
store_whole_genome=False, cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 200, 1, 1))
# there is one read in the region
np.testing.assert_allclose(cover[4].sum(), 36.)
np.testing.assert_allclose(cover[52].sum(), 2*36.)
def test_load_cover_bigwig_resolution1(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bwfile_ = os.path.join(data_path, "sample.bw")
bed_file = os.path.join(data_path, "sample.bed")
for store in ['ndarray', 'hdf5', 'sparse']:
# base pair binsize
print(store)
cover = Cover.create_from_bigwig(
"cov",
bigwigfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=200,
resolution=1,
storage=store, cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 200, 1, 1))
# there is one read in the region 4
np.testing.assert_allclose(cover[4].sum(), 36)
np.testing.assert_equal(cover[4][0, :, 0, 0],
np.asarray(
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]))
# and two reads in region 52
np.testing.assert_allclose(cover[52].sum(), 2*36)
np.testing.assert_equal(cover[52][0, :, 0, 0],
np.asarray(
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]))
def test_load_cover_bigwig_resolutionNone(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bwfile_ = os.path.join(data_path, "sample.bw")
bed_file = os.path.join(data_path, "sample.bed")
for store in ['ndarray', 'hdf5', 'sparse']:
# base pair binsize
print(store)
cover1 = Cover.create_from_bigwig(
"cov",
bigwigfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=200,
resolution=1,
storage=store, cache=True)
cover = Cover.create_from_bigwig(
"cov",
bigwigfiles=bwfile_,
roi=bed_file,
binsize=200, stepsize=200,
resolution=None,
storage=store, cache=True,
collapser='sum')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 1))
np.testing.assert_equal(cover1[:].sum(axis=1), cover[:].sum(axis=1))
def test_load_cover_bed_binary(tmpdir):
os.environ['JANGGU_OUTPUT'] = tmpdir.strpath
bed_file = pkg_resources.resource_filename('janggu', 'resources/sample.bed')
score_file = pkg_resources.resource_filename('janggu',
'resources/scored_sample.bed')
for store in ['ndarray', 'hdf5', 'sparse']:
print('store', store)
cover = Cover.create_from_bed(
"cov",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
storage=store,
mode='binary', cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
storage=store,
resolution=50,
collapser='max',
mode='binary', cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 4, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 4*1)
cover = Cover.create_from_bed(
"cov50_firstdim",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
storage=store,
resolution=None,
collapser='max',
mode='binary', cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
cover = Cover.create_from_bed(
"cov50_firstdim",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
storage=store,
store_whole_genome=True,
resolution=200,
collapser='max',
mode='binary', cache=True)
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
def test_load_cover_bed_scored():
bed_file = pkg_resources.resource_filename('janggu', 'resources/sample.bed')
score_file = pkg_resources.resource_filename('janggu',
'resources/scored_sample.bed')
for store in ['ndarray', 'sparse']:
cover = Cover.create_from_bed(
"cov",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
storage=store,
store_whole_genome=True,
mode='score')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 5)
np.testing.assert_equal(cover[50].sum(), 0)
np.testing.assert_equal(cover[54].sum(), 4)
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
storage=store,
resolution=50,
mode='score')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 4, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 4*5)
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
storage=store,
resolution=None,
binsize=200, stepsize=200,
collapser='max',
mode='score')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 5)
def test_load_cover_bed_categorical():
bed_file = pkg_resources.resource_filename('janggu', 'resources/sample.bed')
score_file = pkg_resources.resource_filename('janggu',
'resources/scored_sample.bed')
with pytest.raises(ValueError):
# Only one bed file allowed.
cover = Cover.create_from_bed(
"cov",
bedfiles=[score_file] * 2,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
mode='categorical')
for store in ['ndarray', 'sparse']:
print(store)
cover = Cover.create_from_bed(
"cov",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
storage=store,
mode='categorical')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 4))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
np.testing.assert_equal(cover[4], [[[[0., 0., 0., 1.]]]])
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=50,
storage=store,
mode='categorical')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 4, 1, 4))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 4*1)
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
resolution=None,
binsize=200, stepsize=200,
storage=store,
collapser='max',
mode='categorical')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 4))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
np.testing.assert_equal(cover[4], [[[[0., 0., 0., 1.]]]])
def test_load_cover_bed_score_category():
bed_file = pkg_resources.resource_filename('janggu', 'resources/sample.bed')
score_file = pkg_resources.resource_filename('janggu',
'resources/scored_sample.bed')
with pytest.raises(ValueError):
# Only one bed file allowed.
cover = Cover.create_from_bed(
"cov",
bedfiles=[score_file] * 2,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
mode='score_category')
for store in ['ndarray', 'sparse']:
print(store)
cover = Cover.create_from_bed(
"cov",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
storage=store,
mode='score_category')
assert cover.conditions == ['1', '2', '4', '5']
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 4))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
np.testing.assert_equal(cover[4], [[[[0., 0., 0., 1.]]]])
cover = Cover.create_from_bed(
"cov",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
conditions=['1', '2', '4', '5'],
storage=store,
mode='score_category')
assert cover.conditions == ['1', '2', '4', '5']
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 4))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
np.testing.assert_equal(cover[4], [[[[0., 0., 0., 1.]]]])
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=50,
storage=store,
mode='score_category')
assert cover.conditions == ['1', '2', '4', '5']
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 4, 1, 4))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 4*1)
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
resolution=None,
binsize=200, stepsize=200,
storage=store,
collapser='max',
mode='score_category')
assert cover.conditions == ['1', '2', '4', '5']
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 4))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
np.testing.assert_equal(cover[4], [[[[0., 0., 0., 1.]]]])
def test_load_cover_bedgraph():
bed_file = pkg_resources.resource_filename('janggu', 'resources/sample.bed')
score_file = pkg_resources.resource_filename('janggu',
'resources/sample.bedgraph')
for store in ['ndarray', 'sparse']:
print(store)
cover = Cover.create_from_bed(
"cov",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
storage=store,
mode='bedgraph')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), .5)
np.testing.assert_equal(cover[4], [[[[.5]]]])
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=50,
storage=store,
mode='bedgraph')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 4, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 4*.5)
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
resolution=None,
binsize=200, stepsize=200,
storage=store,
collapser='max',
mode='bedgraph')
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 1))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), .5)
np.testing.assert_equal(cover[4], [[[[.5]]]])
def test_load_cover_bed_name_category():
bed_file = pkg_resources.resource_filename('janggu', 'resources/sample.bed')
score_file = pkg_resources.resource_filename('janggu',
'resources/scored_sample.bed')
with pytest.raises(ValueError):
# Only one bed file allowed.
cover = Cover.create_from_bed(
"cov",
bedfiles=[score_file] * 2,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
mode='name_category')
for store in ['ndarray', 'sparse']:
print(store)
cover = Cover.create_from_bed(
"cov",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
storage=store,
mode='name_category')
assert cover.conditions == ['state1', 'state2']
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 2))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
np.testing.assert_equal(cover[3], [[[[1., 0.]]]])
np.testing.assert_equal(cover[4], [[[[0., 1.]]]])
cover = Cover.create_from_bed(
"cov",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=200,
conditions=['state1', 'state2'],
storage=store,
mode='name_category')
assert cover.conditions == ['state1', 'state2']
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 2))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
np.testing.assert_equal(cover[3], [[[[1., 0.]]]])
np.testing.assert_equal(cover[4], [[[[0., 1.]]]])
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
binsize=200, stepsize=200,
resolution=50,
storage=store,
mode='name_category')
assert cover.conditions == ['state1', 'state2']
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 4, 1, 2))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 4*1)
cover = Cover.create_from_bed(
"cov50",
bedfiles=score_file,
roi=bed_file,
resolution=None,
binsize=200, stepsize=200,
storage=store,
collapser='max',
mode='name_category')
assert cover.conditions == ['state1', 'state2']
np.testing.assert_equal(len(cover), 100)
np.testing.assert_equal(cover.shape, (100, 1, 1, 2))
np.testing.assert_equal(cover[0].sum(), 0)
np.testing.assert_equal(cover[4].sum(), 1)
np.testing.assert_equal(cover[3], [[[[1., 0.]]]])
np.testing.assert_equal(cover[4], [[[[0., 1.]]]])
def test_filter_by_region():
roi_file = pkg_resources.resource_filename('janggu',
'resources/bed_test.bed')
roi = GenomicIndexer.create_from_file(regions=roi_file, binsize=2, stepsize=2)
np.testing.assert_equal(len(roi), 9)
np.testing.assert_equal((roi[0].chrom, roi[0].start, roi[0].end), ('chr1', 0, 2))
np.testing.assert_equal((roi[-1].chrom, roi[-1].start, roi[-1].end), ('chr1', 16, 18))
test1 = roi.filter_by_region(include='chr1', start=0, end=18)
for i in range(len(test1)):
np.testing.assert_equal(test1[i], roi[i])
test2 = roi.filter_by_region(include='chr1', start=5, end=10)
np.testing.assert_equal(len(test2), 3)
np.testing.assert_equal((test2[0].chrom, test2[0].start, test2[0].end), ('chr1', 4, 6))
np.testing.assert_equal((test2[1].chrom, test2[1].start, test2[1].end), ('chr1', 6, 8))
np.testing.assert_equal((test2[2].chrom, test2[2].start, test2[2].end), ('chr1', 8, 10))
test3 = roi.filter_by_region(include='chr1', start=5, end=11)
np.testing.assert_equal(len(test3), 4)
np.testing.assert_equal((test3[0].chrom, test3[0].start, test3[0].end), ('chr1', 4, 6))
np.testing.assert_equal((test3[1].chrom, test3[1].start, test3[1].end), ('chr1', 6, 8))
np.testing.assert_equal((test3[2].chrom, test3[2].start, test3[2].end), ('chr1', 8, 10))
np.testing.assert_equal((test3[3].chrom, test3[3].start, test3[3].end), ('chr1', 10, 12))
test4 = roi.filter_by_region(include='chr1', start=6, end=10)
np.testing.assert_equal(len(test4), 2)
np.testing.assert_equal((test4[0].chrom, test4[0].start, test4[0].end), ('chr1', 6, 8))
np.testing.assert_equal((test4[1].chrom, test4[1].start, test4[1].end), ('chr1', 8, 10))
test5 = roi.filter_by_region(include='chr1', start=6, end=11)
np.testing.assert_equal(len(test5), 3)
np.testing.assert_equal((test5[0].chrom, test5[0].start, test5[0].end), ('chr1', 6, 8))
np.testing.assert_equal((test5[1].chrom, test5[1].start, test5[1].end), ('chr1', 8, 10))
np.testing.assert_equal((test5[2].chrom, test5[2].start, test5[2].end), ('chr1', 10, 12))
test6 = roi.filter_by_region(include='chr1', start=20, end=30)
np.testing.assert_equal(len(test6), 0)
def test_plotgenometracks_bigwigs():
roi = pkg_resources.resource_filename('janggu', 'resources/sample.bed')
bw_file = pkg_resources.resource_filename('janggu', 'resources/sample.bw')
cover = Cover.create_from_bigwig('coverage2',
bigwigfiles=bw_file,
roi=roi,
binsize=200,
stepsize=200,
resolution=50)
cover2 = Cover.create_from_bigwig('morecoverage',
bigwigfiles=[bw_file] * 4,
roi=roi,
binsize=200,
stepsize=200,
resolution=50)
# line plots
a = plotGenomeTrack([cover,cover2],'chr1',16000,18000)
a = plotGenomeTrack(cover,'chr1',16000,18000)
a = plotGenomeTrack(LineTrack(cover),'chr1',16000,18000)
a = plotGenomeTrack([cover,cover2],'chr1',16000,18000, plottypes=['heatmap'] * 2)
with pytest.raises(AssertionError):
# differing number of plottypes and coverage objects raises an error
a = plotGenomeTrack(cover,'chr1',16000,18000, plottypes=['heatmap'] * 2)
with pytest.raises(ValueError):
# coverage not a sequence
a = plotGenomeTrack(cover,'chr1',16000,18000, plottypes=['seqplot'])
with pytest.raises(ValueError):
# coverage not a sequence
a = plotGenomeTrack(cover2,'chr1',16000,18000, plottypes=['seqplot'])
def test_plotgenometracks_bams():
roi = pkg_resources.resource_filename('janggu', 'resources/sample.bed')
bw_file = pkg_resources.resource_filename('janggu', 'resources/sample.bam')
cover = Cover.create_from_bam('coverage',
bamfiles=bw_file,
roi=roi,
binsize=200,
stepsize=200,
resolution=50)
# line plots
a = plotGenomeTrack(cover,'chr1',16000,18000)
a = plotGenomeTrack([cover,cover],'chr1',16000,18000, plottypes=['heatmap'] * 2)
a = plotGenomeTrack([HeatTrack(cover), HeatTrack(cover)],'chr1',16000,18000)
a = plotGenomeTrack([LineTrack(cover)],'chr1',16000,18000)
def test_plotgenometracks_seqplot():
roi = pkg_resources.resource_filename('janggu', 'resources/sample.bed')
refgenome = pkg_resources.resource_filename('janggu',
'resources/sample_genome.fa')
dna = Bioseq.create_from_refgenome('dna', refgenome=refgenome,
storage='ndarray',
roi=roi, order=1,
store_whole_genome=True)
a = plotGenomeTrack(dna,'chr1',16000,18000, plottypes=['seqplot'])
a = plotGenomeTrack(SeqTrack(dna), 'chr1', 16000, 18000)
def test_padding_value_nan():
variantsfile = pkg_resources.resource_filename('janggu', 'resources/pseudo_snps.vcf')
gindexer = GenomicIndexer.create_from_file(variantsfile, None, None)
array = np.zeros((len(gindexer), 3))
snpcov = Cover.create_from_array('snps', array,
gindexer,
store_whole_genome=True,
padding_value=np.nan)
assert snpcov.shape == (6, 1, 1, 3)
np.testing.assert_equal(snpcov['pseudo1', 650, 670][0,:,0,0],
np.array([np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,
0., np.nan, 0., np.nan, 0., 0., 0.,
np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]))
snpcov = Cover.create_from_array('snps', array,
gindexer,
store_whole_genome=False,
padding_value=np.nan)
assert snpcov.shape == (6, 1, 1, 3)
np.testing.assert_equal(snpcov['pseudo1', 650, 670][0,:,0,0],
np.array([np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,
0., np.nan, 0., np.nan, 0., 0., 0.,
np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]))
def test_bedgraph():
data_path = pkg_resources.resource_filename('janggu', 'resources/')
bed_file = os.path.join(data_path, "positive.bed")
bgfile_ = os.path.join(data_path, "positive.bedgraph")
cover1 = Cover.create_from_bed(
'test',
bedfiles=bgfile_,
roi=bed_file,
mode='bedgraph',
store_whole_genome=True)
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bgfile_,
roi=bed_file,
mode='bedgraph',
store_whole_genome=False)
assert len(cover1) == 25
assert len(cover2) == len(cover1)
assert cover1.shape == (25, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
def test_fulltilebigwig():
import pkg_resources
import os
from janggu.data import Cover
data_path = pkg_resources.resource_filename('janggu', 'resources/')
roi = os.path.join(data_path, "sample_fulltile.bed")
bwfile = os.path.join(data_path, "sample.bw")
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile,
roi=roi,
store_whole_genome=True)
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile,
roi=roi,
store_whole_genome=False)
assert len(cover1) == 2
assert len(cover2) == len(cover1)
assert cover1.shape == (2, 30000, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile,
roi=roi, binsize=200,
store_whole_genome=True)
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile,
roi=roi, binsize=200,
store_whole_genome=False)
assert len(cover1) == 300
assert len(cover2) == len(cover1)
assert cover1.shape == (300, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile,
roi=roi, binsize=200,
flank=150,
store_whole_genome=True)
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile,
roi=roi, binsize=200,
flank=150,
store_whole_genome=False)
assert len(cover1) == 300
assert len(cover2) == len(cover1)
assert cover1.shape == (300, 500, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
def test_fulltilebigwig2():
import pkg_resources
import os
from janggu.data import Cover
data_path = pkg_resources.resource_filename('janggu', 'resources/')
roi = os.path.join(data_path, "sample_fulltile2.bed")
bwfile = os.path.join(data_path, "sample.bw")
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile,
roi=roi,
store_whole_genome=True)
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile,
roi=roi,
store_whole_genome=False)
assert len(cover1) == 3
assert len(cover2) == len(cover1)
assert cover1.shape == (3, 30000, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile,
roi=roi, binsize=200,
store_whole_genome=True)
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile,
roi=roi, binsize=200,
store_whole_genome=False)
assert len(cover1) == 450
assert len(cover2) == len(cover1)
assert cover1.shape == (450, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bigwig(
'test',
bigwigfiles=bwfile,
roi=roi, binsize=200,
flank=150,
store_whole_genome=True)
cover2 = Cover.create_from_bigwig(
'test2',
bigwigfiles=bwfile,
roi=roi, binsize=200,
flank=150,
store_whole_genome=False)
assert len(cover1) == 450
assert len(cover2) == len(cover1)
assert cover1.shape == (450, 500, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
def test_fulltilebam():
import pkg_resources
import os
from janggu.data import Cover
data_path = pkg_resources.resource_filename('janggu', 'resources/')
roi = os.path.join(data_path, "sample_fulltile.bed")
bwfile = os.path.join(data_path, "sample.bam")
cover1 = Cover.create_from_bam(
'test',
bamfiles=bwfile,
roi=roi,
stranded=False,
store_whole_genome=True)
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bwfile,
stranded=False,
roi=roi,
store_whole_genome=False)
assert len(cover1) == 2
assert len(cover2) == len(cover1)
assert cover1.shape == (2, 30000, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bam(
'test',
bamfiles=bwfile,
roi=roi, binsize=200,
stranded=False,
store_whole_genome=True)
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bwfile,
roi=roi, binsize=200,
stranded=False,
store_whole_genome=False)
assert len(cover1) == 300
assert len(cover2) == len(cover1)
assert cover1.shape == (300, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bam(
'test',
bamfiles=bwfile,
roi=roi, binsize=200,
flank=150,
stranded=False,
store_whole_genome=True)
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bwfile,
roi=roi, binsize=200,
flank=150,
stranded=False,
store_whole_genome=False)
assert len(cover1) == 300
assert len(cover2) == len(cover1)
assert cover1.shape == (300, 500, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
def test_fulltilebam2():
import pkg_resources
import os
from janggu.data import Cover
data_path = pkg_resources.resource_filename('janggu', 'resources/')
roi = os.path.join(data_path, "sample_fulltile2.bed")
bwfile = os.path.join(data_path, "sample.bam")
cover1 = Cover.create_from_bam(
'test',
bamfiles=bwfile,
roi=roi,
stranded=False,
store_whole_genome=True)
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bwfile,
roi=roi,
stranded=False,
store_whole_genome=False)
assert len(cover1) == 3
assert len(cover2) == len(cover1)
assert cover1.shape == (3, 30000, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bam(
'test',
bamfiles=bwfile,
roi=roi, binsize=200,
stranded=False,
store_whole_genome=True)
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bwfile,
roi=roi, binsize=200,
stranded=False,
store_whole_genome=False)
assert len(cover1) == 450
assert len(cover2) == len(cover1)
assert cover1.shape == (450, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bam(
'test',
bamfiles=bwfile,
roi=roi, binsize=200,
flank=150,
stranded=False,
store_whole_genome=True)
cover2 = Cover.create_from_bam(
'test2',
bamfiles=bwfile,
roi=roi, binsize=200,
flank=150,
stranded=False,
store_whole_genome=False)
assert len(cover1) == 450
assert len(cover2) == len(cover1)
assert cover1.shape == (450, 500, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
def test_fulltilebed():
import pkg_resources
import os
from janggu.data import Cover
data_path = pkg_resources.resource_filename('janggu', 'resources/')
roi = os.path.join(data_path, "sample_fulltile.bed")
bwfile = os.path.join(data_path, "sample.bed")
cover1 = Cover.create_from_bed(
'test',
bedfiles=bwfile,
roi=roi,
store_whole_genome=True)
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bwfile,
roi=roi,
store_whole_genome=False)
assert len(cover1) == 2
assert len(cover2) == len(cover1)
assert cover1.shape == (2, 30000, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bed(
'test',
bedfiles=bwfile,
roi=roi, binsize=200,
store_whole_genome=True)
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bwfile,
roi=roi, binsize=200,
store_whole_genome=False)
assert len(cover1) == 300
assert len(cover2) == len(cover1)
assert cover1.shape == (300, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bed(
'test',
bedfiles=bwfile,
roi=roi, binsize=200,
flank=150,
store_whole_genome=True)
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bwfile,
roi=roi, binsize=200,
flank=150,
store_whole_genome=False)
assert len(cover1) == 300
assert len(cover2) == len(cover1)
assert cover1.shape == (300, 500, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
def test_fulltilebed2():
import pkg_resources
import os
from janggu.data import Cover
data_path = pkg_resources.resource_filename('janggu', 'resources/')
roi = os.path.join(data_path, "sample_fulltile2.bed")
bwfile = os.path.join(data_path, "sample.bed")
cover1 = Cover.create_from_bed(
'test',
bedfiles=bwfile,
roi=roi,
store_whole_genome=True)
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bwfile,
roi=roi,
store_whole_genome=False)
assert len(cover1) == 3
assert len(cover2) == len(cover1)
assert cover1.shape == (3, 30000, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bed(
'test',
bedfiles=bwfile,
roi=roi, binsize=200,
store_whole_genome=True)
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bwfile,
roi=roi, binsize=200,
store_whole_genome=False)
assert len(cover1) == 450
assert len(cover2) == len(cover1)
assert cover1.shape == (450, 200, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
cover1 = Cover.create_from_bed(
'test',
bedfiles=bwfile,
roi=roi, binsize=200,
flank=150,
store_whole_genome=True)
cover2 = Cover.create_from_bed(
'test2',
bedfiles=bwfile,
roi=roi, binsize=200,
flank=150,
store_whole_genome=False)
assert len(cover1) == 450
assert len(cover2) == len(cover1)
assert cover1.shape == (450, 500, 1, 1)
assert cover1.shape == cover2.shape
np.testing.assert_equal(cover1[:], cover2[:])
Datasets
Models
