def test_hp_task_creation():
"test fit to hp dataframe"
task = FitToHairpinTask(
sequence = utpath("hairpins.fasta"),
oligos = "ctgc",
fit = ChiSquareFit(),
)
assert isinstance(task.fit.pop(None), ChiSquareFit)
assert set(task.fit) == {'015', *(f"GF{i}" for i in range(1, 5))}
assert all(isinstance(i, ChiSquareFit) for i in task.fit.values())
assert_equal(task.fit['GF4'].peaks, [153, 205, 407, 496, 715, 845])
assert all(isinstance(i, ChiSquareFit) for i in task.fit.values())
task = FitToHairpinTask(
sequence = utpath("hairpins.fasta"),
oligos = "ctgc",
fit = PeakGridFit(),
)
assert isinstance(task.fit.pop(None), PeakGridFit)
assert set(task.fit) == {'015', *(f"GF{i}" for i in range(1, 5))}
assert all(isinstance(i, PeakGridFit) for i in task.fit.values())
for i in PeakGridFit(), ChiSquareFit():
task = FitToHairpinTask(
sequence = "doesnotexist.fasta",
oligos = "ctgc",
fit = i
)
assert isinstance(task.fit.pop(None), type(i))
assert not task.fit
def test_rampdatacleaning():
"test RampDataCleaningTask in scripting context"
filepath = "Ramp-fov5-PBS_AfterDNApol1.pk"
beadid = 0 # the only bead in the pk-file
proc_pass = create(
TrackReaderTask(path=utpath(filepath)),
RampDataCleaningTask(minpopulation=20,
extentoutlierspercentile=90,
minextentoutliers=90))
proc_fail = create(
TrackReaderTask(path=utpath(filepath)),
RampDataCleaningTask(minpopulation=100,
extentoutlierspercentile=95,
minextentoutliers=90,
maxhfsigma=.0002))
data_pass = next(iter(proc_pass.run()))
num_datapoints = data_pass[beadid].shape[0]
num_valid_point = np.sum(np.isfinite(data_pass[beadid]))
assert num_valid_point / data_pass.nframes == pytest.approx(
10 / 22, rel=1e-4) # 10/22 cyc pass
data_fail = next(iter(proc_fail.run()))
with pytest.raises(
DataCleaningException,
match=re.escape('22 cycles: σ[HF] > 0.0002\n' +
'12 cycles: Δz-outlier < 90% of Δz-consensus')):
data_fail[beadid]
def test_taskdialog_fit_view(pkviewserver):
"test the view"
server = pkviewserver()[0]
server.ctrl.theme.model("peakcalling.view.stats").linear = False
server.addhp(sequences=utpath("hp6.fasta"), oligos=["aacc"], rendered=True)
assert set(server.task(FitToHairpinTask).sequences) == {
'full', 'oligo', 'target'
}
assert server.task(FitToHairpinTask).oligos == ['aacc']
assert set(
server.task(FitToHairpinTask).fit) == {'full', 'oligo', 'target'}
modal = server.selenium.modal("//span[@class='icon-dpx-cog']", True)
with modal:
modal.tab("Hairpins")
modal[f"//input[@name='items[0].fit.task.sequences']"] = str(
utpath("hairpins.fasta"))
modal.tab("Oligos")
modal[f"//input[@name='items[0].fit.task.oligos']"] = "kmer"
server.wait()
assert set(server.task(FitToHairpinTask).sequences) == {
'015', *(f'GF{i}' for i in range(1, 5))
}
assert server.task(FitToHairpinTask).oligos == ['ctgt']
assert set(server.task(FitToHairpinTask).fit) == {
'015', *(f'GF{i}' for i in range(1, 5))
}
with modal:
assert (modal[f"//input[@name='items[0].fit.task.sequences']"].
get_attribute('value') == str(utpath("hairpins.fasta")))
assert (modal[f"//input[@name='items[0].fit.task.oligos']"].
get_attribute('value') == "ctgt")
def test_subtraction_dataframe():
"test cleanin creation"
proc = create(TrackReaderTask(path=utpath("fixedbeads.pk")),
DataFrameTask(merge=True, measures={'status': True}))
data = next(iter(proc.run()))
assert list(data[data.fixed].reset_index().bead) == [4]
assert 'status' in data.columns
assert isinstance(data.status.values[0], pd.DataFrame)
assert data[data.fixed].reset_index().status[0].shape[0] == 0
assert 'modification' in data.columns
assert hasattr(data, 'tasklist')
proc = create(TrackReaderTask(path=utpath("fixedbeads.pk")),
DataCleaningTask(),
DataFrameTask(merge=True, measures={'status': True}))
data = next(iter(proc.run()))
assert list(data[data.fixed].reset_index().bead) == [4]
assert 'status' in data.columns
assert isinstance(data.status.values[0], pd.DataFrame)
assert data[data.fixed].reset_index().status[0].shape[0] != 0
proc = create(TrackReaderTask(path=utpath("fixedbeads.pk")),
DataFrameTask(merge=True, measures={'fixed': True}))
data = next(iter(proc.run()))
assert list(data[data.fixed].reset_index().bead) == [4]
assert 'status' not in data.columns
proc = create(TrackReaderTask(path=utpath("fixedbeads.pk")),
DataCleaningTask(),
DataFrameTask(merge=True, measures={'fixed': True}))
data = next(iter(proc.run()))
assert list(data[data.fixed].reset_index().bead) == [4]
assert 'status' not in data.columns
def test_loadgrdir():
paths = utpath("big_legacy"), utpath("big_grlegacy")
for time in range(2):
if time == 1:
paths = (
paths[:1] # type: ignore
+ tuple(
str(i) for i in Path(cast(str, paths[1])).iterdir()
if i.suffix == '.gr'))
paths = paths[5:] + paths[:5] # type:ignore
track = data.Track(path=paths)
keys = {
0, 10, 12, 13, 14, 16, 17, 18, 1, 21, 22, 23, 24, 25, 26, 27, 28,
29, 2, 34, 35, 37, 3, 4, 6, 7
}
assert set(track.beads.keys()) == keys
keys = {
17, 23, 41, 14, 31, 45, 18, 37, 44, 7, 32, 6, 48, 22, 24, 47, 28,
19, 30, 25, 43, 42, 8, 26, 16, 12, 9, 33, 35, 27, 3, 10, 21, 15,
34, 29, 13, 5, 4, 20, 46, 11
}
keys = {i - 3 for i in keys}
good = {
i[1]
for i, j in track.cycles[28, ...] if not np.all(np.isnan(j))
}
assert good == keys
assert len(good) < track.ncycles
assert all(
np.isfinite(j).sum() == 0
for _, j in track.cycles.withphases(0)[28, ...])
def test_lru():
tasks = [TrackReaderTask(utpath("big_legacy")), _Ref()]
lru = _RootCache(2)
info = {}
assert info is lru.setdefault(tasks, info)
assert info is lru.setdefault(tasks, None)
assert info is lru[tasks]
assert tasks in lru
lru[tasks] = cache = {}
assert tasks in lru
assert info is not lru[tasks]
assert cache is lru[tasks]
tasks = [TrackReaderTask(utpath("big_legacy")), _Ref()]
assert cache is lru.setdefault(tasks, None)
tasks2 = [TrackReaderTask(utpath("big_legacy"))]
assert tasks2 not in lru
info2 = lru.setdefault(tasks2, None)
assert info2 is lru.setdefault(tasks2, None)
tasks3 = [TrackReaderTask(utpath("big_legacy")), _Ref(), _Hairpin()]
lru.setdefault(tasks3, None)
assert tasks not in lru
assert tasks2 in lru
del lru[tasks2]
assert tasks2 not in lru
def test_cycles_lazy():
"tests what happens when using lazy mode"
truth = readtrack(utpath("big_legacy"))[0]
for _, vals in data.Cycles(
track=lambda _: data.Track(path=utpath("big_legacy")),
first=lambda _: 2,
last=lambda _: 3,
selected=lambda _: [(0, 1)]):
assert np.array_equal(vals, truth[1206 - 678:1275 - 678])
def test_confusion(scriptingcleaner):
"test the confusion matrix"
from scripting import Track
from scripting.confusion import ConfusionMatrix, LNAHairpin
from tests.testingcore import path as utpath
peaks = pickle.load(open(cast(str, utpath("hp6jan2018.peaks")), "rb"))
peaks = peaks[peaks.track != 'ref']
cnf = ConfusionMatrix(oligos = peaks.track.unique(),
seq = LNAHairpin(path = utpath("hp6.fasta")))
det = cnf.detection(peaks)
conf = cnf.confusion(det)
return det, conf
def test_allleaves():
'tests pairing of track files and gr-files in the absence of cgr'
trkpath = str(Path(cast(str, utpath("big_legacy"))).parent / '*.trk')
print(trkpath)
grpath = str(Path(cast(str, utpath("big_grlegacy"))) / '*.gr')
print(grpath)
good, _1, _2 = LegacyGRFilesIO.scan(trkpath,
grpath,
cgrdir="",
allleaves=True)
assert len(good) == 1
trks = [str(path[0]) for path in good]
assert utpath("big_legacy") in trks
def test_muwells(scriptingcleaner):
"test µwells"
from scripting import Track
from tests.testingcore import path as utpath
trackfile = utpath("muwells/W6N46_HPB20190107_W2_OR134689_cycle_1.9-2.10_TC10m.trk")
liafile = utpath("muwells/W6N46_HPB20190107_OR134689_cycle_1.9-2.10_TC10m.txt")
track = Track(path= (trackfile, liafile))
assert set(track.tasks.tasks.keys()) == set()
other = track.op.rescaletobead(0)
assert track is not other
assert set(other.tasks.tasks.keys()) == {
'cleaning', 'alignment', 'eventdetection', 'peakselector'
}
def test_rawprecisiontask():
"test raw precision task"
for i in ('range', 'normalized'):
# test that track is opened with the correct raw precision computer
tsk = RawPrecisionTask(computer=i)
trk = next(iter(create(utpath("big_all"), tsk).run())).track
assert trk.rawprecision().keyword() == i
# test that track is copied whenever the requested raw precision
# computer is different from the original one
tsk.computer = 'range' if i == 'normalized' else 'normalized'
trk2 = next(iter(create(utpath("big_all"), tsk).run())).track
assert trk.rawprecision().keyword() == i
assert trk2.rawprecision().keyword() == tsk.computer
def test_cycleprocess_emptycycles():
"tests drift removal on cycles"
tasks = (utpath("big_all"),
ExtremumAlignmentTask(phase = 'pull', minpopulation = 0.),
DriftTask(onbeads = False))
ret = dict(next(i for i in create(tasks).run()))
assert ret is not None # check that computations don't crash
def test_io_recognition():
"tests that the right IO class recognizes its paths"
get = lambda i: str(utpath(i))
files = dict(pickles=(
(get("100bp_4mer/ref.pk"), ),
get("100bp_4mer/ref.pk"),
),
tracks=(
(get("small_legacy"), ),
get("small_legacy"),
),
grs=((get("big_legacy"), get("CTGT_selection")),
(get("big_legacy"),
get("CTGT_selection") + "/Z(t)bd0track10.gr")),
none=(
get("CTGT_selection"),
get("CTGT_selection") + "/Z(t)bd0track10.gr",
(get("CTGT_selection") + "/Z(t)bd0track10.gr"),
))
types = dict(pickles=PickleIO, tracks=LegacyTrackIO, grs=LegacyGRFilesIO)
for tpename, tpe in types.items():
for fname, paths in files.items():
for path in cast(Iterable, paths):
assert (tpe.check(path) is None) is (tpename != fname)
def test_beaditerkeys():
"tests wether keys are well listed"
track = data.Track(path=utpath("small_legacy"))
beads = lambda: data.Beads(track=track, data=_MyItem(track.data))
vals = set(range(92))
assert len(tuple(beads().keys())) == len(vals)
assert len(tuple(i for i, _ in beads())) == len(vals)
assert len(tuple(beads().selecting(all).keys())) == len(vals)
assert len(tuple(beads().selecting(None).keys())) == len(vals)
assert len(tuple(beads()[:].keys())) == len(vals)
assert len(tuple(beads()[:2].keys())) == len({0, 1})
assert len(tuple(beads()[:2][1:5].keys())) == len({1}) # pylint: disable=unsubscriptable-object
assert set(beads().keys()) == vals
assert set(i for i, _ in beads()) == vals
assert set(beads().selecting(all).keys()) == vals
assert set(beads().selecting(None).keys()) == vals
assert set(beads()[:].keys()) == vals
assert set(beads()[:2].keys()) == {0, 1}
assert set(beads()[:2][1:5].keys()) == {1} # pylint: disable=unsubscriptable-object
assert isinstance(beads()[0], np.ndarray)
sel = track.beads
assert tuple(beads().selecting([2, 3, 2]).keys()) == (2, 3, 2)
assert tuple(i for i, _ in sel.selecting([2, 3, 2])) == (2, 3, 2)
assert tuple(sel.selecting(2, clear=True).keys()) == (2, )
assert tuple(beads().selecting(range(50)).discarding(range(
1, 48)).keys()) == (0, 48, 49)
assert tuple(beads().selecting(2).selecting([2, 3]).keys()) == (2, 2, 3)
def test_toref_frompeaks():
"tests reference comparison"
pair = create(utpath("big_selected"), EventDetectionTask(), PeakSelectorTask())
pks = {i: tuple(j) for i, j in next(iter(pair.run()))}
res = HistogramFit().frompeaks(next(iter(pks.values())))
ret = HistogramFit().optimize(res, HistogramData(res.histogram,
res.minvalue+.01,
res.binwidth/1.01))
assert_allclose(ret[1:], [1.01, .01], rtol = 5e-4, atol = 5e-4)
pair = create(utpath("big_selected"), EventDetectionTask(), PeakSelectorTask())
pks = {i: tuple(j) for i, j in next(iter(pair.run()))}
res = ReferencePeaksFit().frompeaks(next(iter(pks.values())))
ret = ReferencePeaksFit().optimize(res, res/1.01+0.1)
assert_allclose(ret[1:], [1.01, .1], rtol = 5e-4, atol = 1e-2)
def test_trackconfig(scriptingcleaner):
"test scripting enhanced track"
from scripting import Track, Tasks, localcontext
from data import Cycles
from eventdetection.data import Events
from peakfinding.processor import PeaksDict
from tests.testingcore import path as utpath
track = Track(path = utpath("big_legacy"))
assert track.path == utpath("big_legacy")
assert set(track.data.keys()) == set(list(range(0,39)))
assert isinstance(track.cleancycles, Cycles)
assert isinstance(track.measures, Cycles)
assert isinstance(track.events, Events)
assert isinstance(track.peaks, PeaksDict)
def test_message_creation():
"test message creation"
proc = create(TrackReaderTask(path=utpath("big_legacy")),
DataCleaningTask())
data = next(iter(proc.run()))
with pytest.raises(DataCleaningException):
data[5]
def test_beadsplot_info_simple(diskcaching):
"test the view"
# pylint: disable=protected-access
beads, mdl = _Fig.create()
# testing for when there is nothing to plot
for cls in _PeaksPlot, _HairpinPlot:
assert (
dict(cls(beads, mdl.tasks.processors)._reset())['x_range']['factors']
== [('track1', '0')]
)
def _change(tpe, **kwa):
mdl.theme.__dict__.update(**kwa)
cls = _PeaksPlot if tpe else _HairpinPlot
return dict(cls(beads, mdl.tasks.processors)._reset())
mdl.tasks.jobs.launch(list(mdl.tasks.processors.values()))
cache = _change(True)
assert cache['x_range']['factors'] == list(zip(
repeat(''), repeat(''),
[
'0', '1', '2', '3', '4', '7', '8', '12', '13', '14', '17', '18', '23',
'24', '25', '27', '33', '34', '35', '37'
]
))
next(iter(mdl.tasks.tasks.tasks.tasks.values())).add(
FitToHairpinTask(
sequence = utpath("hairpins.fasta"),
oligos = "4mer",
),
mdl.tasks.tasks.state.processors[FitToHairpinTask]
)
mdl.tasks.jobs.launch(list(mdl.tasks.processors.values()))
cache = _change(False)
assert cache['x_range']['factors'] == [
('GF1', '', '14'), ('GF1', '', '33'), ('GF1', '', '1'), ('GF1', '', '7'),
('GF1', '', '25'), ('GF1', '', '35'), ('GF1', '', '12'), ('GF3', '', '27'),
('GF3', '', '13'), ('GF3', '', '3'), ('GF3', '', '17'), ('GF3', '', '37'),
('GF3', '', '23'), ('GF3', '', '18'), ('GF4', '', '34'), ('GF4', '', '0'),
('GF4', '', '4'), ('GF4', '', '24'), ('GF2', '', '2')
]
mdl.display.hairpins = {'015', 'GF2', 'GF3', 'GF4'}
cache = _change(False)
assert cache['x_range']['factors'] == [
('GF1', '', '14'), ('GF1', '', '33'), ('GF1', '', '1'), ('GF1', '', '7'),
('GF1', '', '25'), ('GF1', '', '35'), ('GF1', '', '12')
]
mdl.theme.sorting = {}
cache = _change(False)
assert cache['x_range']['factors'] == [
('GF1', '', '1'), ('GF1', '', '7'), ('GF1', '', '12'), ('GF1', '', '14'),
('GF1', '', '25'), ('GF1', '', '33'), ('GF1', '', '35')
]
def test_concatenate():
'test whether two Track stack properly'
trk1 = Track(path=utpath("small_legacy"))
trk2 = dropbeads(Track(path=utpath("small_legacy")), 0)
size1, size2 = [next(iter(x.data.values())).size for x in (trk1, trk2)]
trk = concatenatetracks(trk1, trk2)
assert set(trk.data.keys()) == (set(trk1.data.keys())
| set(trk2.data.keys()))
assert all((trk.secondaries.frames[1:] - trk.secondaries.frames[:-1]) == 1)
assert all(np.isnan(trk.data[0][-size2:]))
assert all(~np.isnan(trk.data[0][:size1]))
assert_allclose(trk.phases[:len(trk1.phases)], trk1.phases)
assert_allclose(
trk.phases[len(trk1.phases):], trk2.phases +
trk1.secondaries.frames[-1] - trk2.secondaries.frames[0] + 1)
def test_findgrdir():
trkpath = str(Path(cast(str, utpath("big_legacy"))).parent / '*.trk')
paths = trkpath, utpath("big_grlegacy")
track = data.Track(path=paths)
keys = {
0, 10, 12, 13, 14, 16, 17, 18, 1, 21, 22, 23, 24, 25, 26, 27, 28, 29,
2, 34, 35, 37, 3, 4, 6, 7
}
assert set(track.beads.keys()) == keys
trkpath = str(Path(cast(str, utpath("big_legacy"))).parent / '*.trk')
paths = trkpath, utpath("big_grlegacy")
track = data.Track(path=paths)
keys = {
0, 10, 12, 13, 14, 16, 17, 18, 1, 21, 22, 23, 24, 25, 26, 27, 28, 29,
2, 34, 35, 37, 3, 4, 6, 7
}
assert set(track.beads.keys()) == keys
def newtasks(mdl, beads=None, withhp=False):
"add a list of tasks to the model"
lst = [
TrackReaderTask(path=utpath("big_legacy")),
DataCleaningTask(),
ClippingTask(),
ExtremumAlignmentTask(),
EventDetectionTask(),
PeakSelectorTask()
]
if beads:
lst.insert(1, DataSelectionTask(selected=list(beads)))
if withhp:
lst.append(
FitToHairpinTask(sequences=utpath("hairpins.fasta"),
oligos="kmer"))
mdl.tasks.tasks.tasks.add(create(lst))
def test_dataframe():
'test whether two Track stack properly'
trk = Track(path=utpath("small_legacy"))
dframe = dataframe(trk)
for i, j in trk.beads:
assert_equal(dframe[f'b{i}'], j)
for i in ("zmag", "phase", "cid"):
assert_equal(dframe[i], getattr(trk.secondaries, i))
assert len({"tsample", "tsink", "tservo"} - set(dframe.columns)) == 0
def test_cleaning_dataframe():
"test cleanin creation"
proc = create(TrackReaderTask(path=utpath("big_legacy")),
DataCleaningTask(), DataFrameTask(merge=True))
data = next(iter(proc.run()))
assert list(data.reset_index(0).loc[5].bad.unique()) == [True]
assert list(data.reset_index(0).loc[0].bad.unique()) == [False]
assert 'modification' in data.columns
assert hasattr(data, 'tasklist')
def test_adapt_procs_ref():
"test processors adaptor remove ref"
procs = [ProcessorController() for i in range(3)]
procs[0].add(TrackReaderTask(utpath("big_legacy")), TrackReaderProcessor)
procs[0].add(_Ref(), _DummyProc)
procs[1].add(TrackReaderTask(utpath("big_legacy")), TrackReaderProcessor)
procs[2].add(TrackReaderTask(utpath("big_legacy")), TrackReaderProcessor)
mdl = TasksModel()
mdl.config.defaulttaskindex = lambda *_: appendtask
for i in (mdl.config.sdi, mdl.config.picotwist):
i['fittoreference'] = _Ref()
i['fittohairpin'] = _Hairpin()
i['dataframe'] = DataFrameTask()
for i in (_Ref, _Hairpin, DataFrameTask):
mdl.state.processors[i] = _DummyProc
mdl.state.processors[TrackReaderTask] = TrackReaderProcessor
for i in procs:
mdl.tasks.add(i)
mdl.dataframes.peaks.measures = {'events': True}
lst = mdl.processors
assert len(lst) == len(procs)
for i in procs:
assert len(lst[i.model[0]].model) == 3
assert i.model is not lst[i.model[0]].model
assert lst[i.model[0]].model[-1].__class__.__name__ == 'DataFrameTask'
assert lst[i.model[0]].model[-1].measures == {'events': True}
mdl.state.reference = procs[1].model[0]
lst = mdl.processors
assert len(lst) == len(procs)
for i in procs:
assert len(lst[i.model[0]].model) == 3 + (i.model[0] is not mdl.state.reference)
assert i.model is not lst[i.model[0]].model
assert lst[i.model[0]].model[-1].__class__.__name__ == 'DataFrameTask'
assert lst[i.model[0]].model[-1].measures == {'events': True}
if i.model[0] is not mdl.state.reference:
assert lst[i.model[0]].model[2].__class__.__name__ == '_Ref'
assert lst[i.model[0]].model[2].defaultdata is lst[mdl.state.reference].data
def test_hp_dataframe(record):
"test fit to hp dataframe"
pair = next(iter(create(
TrackReaderTask(path = utpath("big_legacy")),
EventDetectionTask(),
PeakSelectorTask(),
FitToHairpinTask(
sequence = utpath("hairpins.fasta"),
oligos = "4mer",
fit = ChiSquareFit()
),
DataFrameTask(merge = True, measures = dict(
peaks = dict(missing = True, peakhfsigma = True)
)),
).run()))
assert pair.shape == (102, 29)
assert 'falseneg' in pair.peaks[1].status.unique()
assert pair.index.names == ['hpin', 'track', 'bead']
assert isinstance(pair.peaks.values[0], pd.DataFrame)
assert 'modification' in pair.columns
assert hasattr(pair, 'tasklist')
assert record["withmissing"].approx(
pair.drop(columns = ['peaks', 'cost', 'modification']).iloc[:5],
atol = 5e-4
)
assert record["peakswithmissing"].approx(
pair.peaks[1].iloc[:5], atol = 5e-4
)
pair = next(iter(create(
TrackReaderTask(path = utpath("big_legacy")),
EventDetectionTask(),
PeakSelectorTask(),
FitToHairpinTask(
sequence = utpath("hairpins.fasta"),
oligos = "4mer",
fit = ChiSquareFit()
),
DataFrameTask(merge = True),
).run()))
assert pair.shape == (102, 26)
assert pair.index.names == ['hpin', 'track', 'bead']
assert 'modification' in pair.columns
assert hasattr(pair, 'tasklist')
def test_task_cache():
"Tests that actions can be cached"
# pylint: disable=unused-variable, too-many-locals,invalid-name
# pylint: disable=too-many-statements,missing-docstring,no-self-use
class TBeads(tasks.Task):
level = tasks.Level.bead
def __init__(self):
super().__init__()
self.dummy = None
calls = []
class TBProc(Processor):
tasktype = TBeads
@Processor.cache
def run(self, _):
def _outp(_, x):
calls.append(1)
return x
return _outp
ctrl = TaskController()
read = tasks.TrackReaderTask(path=utpath("small_legacy"))
tb = TBeads()
ctrl.opentrack(read, (read, tb))
assert ctrl.cache(read, tb)() is None
ctrl.run(read, tb)
dt = ctrl.cache(read, tb)()
assert dt is not None
assert len(dt) == 0
tuple(ctrl.run(read, tb))
assert len(dt) == 1
assert len(next(iter(dt.values()))) == 0
tuple(bead for frame in ctrl.run(read, tb) for bead in frame)
sz = len(calls)
assert len(next(iter(dt.values()))) == sz
tuple(ctrl.run(read, tb))
assert len(calls) == sz
ctrl.updatetask(read, tb, dummy=1)
assert ctrl.cache(read, tb)() is None
v1 = next(iter(next(ctrl.run(read, tb))))[1]
v2 = next(iter(ctrl.run(read, read)[0]))[1]
dt = ctrl.cache(read, tb)()
assert len(dt) == 1
assert len(next(iter(dt.values()))) == 1
assert numpy.array_equal(v1, v2)
assert v1 is not v2
def test_tracksdict_ramps_dataframe(scriptingcleaner):
"test TracksDict.basedataframe"
from scripting import TracksDict
from tests.testingcore import path as utpath
tracks = TracksDict(utpath("100bp_4mer")+"/../ramp*.trk")
dframe = tracks.dataframe(ramps = True)
assert 'modification' in dframe.columns
assert hasattr(dframe, 'tasklist')
assert dframe.tasklist[0][-1].__class__.__name__.startswith("Ramp")
def test_tracksdict_hpfit_dataframe(scriptingcleaner):
"test that we can launch a fit to hp on a tracksdict"
from scripting import TracksDict
from tests.testingcore import path as utpath
import pandas as pd
tracks = TracksDict()
tracks['xxx'] = utpath("big_legacy")
frame = tracks.peaks.dataframe(sequence = utpath("hairpins.fasta"), oligos = '4mer')
assert isinstance(frame, pd.DataFrame)
assert len(frame.tasklist) == 1
assert isinstance(frame.tasklist[0], list)
assert frame.tasklist[0][-2].oligos == "4mer"
assert list(frame.oligo.unique()) == ["ctgt"]
assert frame.shape == (80, 27)
assert frame.index.names == ['hpin', 'track', 'bead']
assert 'trackcount' in frame.columns
assert 'modification' in frame.columns
assert hasattr(frame, 'tasklist')
def test_track(scriptingcleaner):
"test scripting enhanced track"
from scripting import Track, Tasks, localcontext, Task
from data import Cycles, Beads
from eventdetection.data import Events
from peakfinding.processor import PeaksDict
from taskmodel import InstrumentType
from tests.testingcore import path as utpath
track = Track(path = utpath("big_legacy"))
assert track.path == utpath("big_legacy")
assert set(track.data.keys()) == set(list(range(0,39)))
for i, j in [
('cleanbeads', Beads),
('cleancycles', Cycles),
('events', Events),
('peaks', PeaksDict)
]:
itm = getattr(track, i)
assert isinstance(itm, j)
assert all(isinstance(k, Task) for k in itm.tasklist)
assert track.cleaned is False
assert ([Tasks(i) for i in Tasks.defaulttasklist(None, Tasks.clipping, False)]
== [Tasks.undersampling, Tasks.cleaning, Tasks.alignment, Tasks.clipping])
assert ([Tasks(i) for i in Tasks.defaulttasklist(track, Tasks.clipping)]
== [Tasks.undersampling, Tasks.cleaning, Tasks.alignment, Tasks.clipping])
assert ([Tasks(i) for i in Tasks.defaulttasklist(track, ...)]
== [Tasks.undersampling, Tasks.cleaning, Tasks.alignment, Tasks.clipping, Tasks.eventdetection,
Tasks.peakselector, Tasks.fittohairpin])
assert ([Tasks(i) for i in Tasks.defaulttasklist(None, Tasks.alignment, True)]
== [Tasks.alignment])
track.cleaned = True
assert ([Tasks(i) for i in Tasks.defaulttasklist(track, Tasks.alignment)]
== [Tasks.alignment])
with localcontext(scripting = {'alignalways': False}):
assert ([Tasks(i) for i in Tasks.defaulttasklist(track, Tasks.alignment)]
== [])
assert track.tasks.subtraction is None
track.tasks.subtraction = 1 # type: ignore
assert set(track.tasks.subtraction.beads) == {1}
track.tasks.subtraction = 1,2
assert set(track.tasks.subtraction.beads) == {1,2}
track.cleaned = False
assert ([Tasks(i) for i in Tasks.defaulttasklist(track, Tasks.alignment)]
== [Tasks.undersampling, Tasks.subtraction, Tasks.cleaning, Tasks.alignment])
assert track.op[:,:5].ncycles == 5
assert set(track.op[[1,2]].beads.keys()) == {1,2}
assert InstrumentType(utpath("big_legacy")) == InstrumentType.picotwist
assert InstrumentType(utpath("sdi_track.pk")) == InstrumentType.sdi
assert Tasks.peakselector(instrument = utpath("big_legacy")).rawfactor == 2.
assert track.peaks.tasklist[-1].rawfactor == 2.
assert Tasks.peakselector(instrument = utpath("sdi_track.pk")).rawfactor == 1.
assert Track(path = utpath("sdi_track.pk")).peaks.tasklist[-1].rawfactor == 1.
def test_tracksdict_creation():
"find all tracks with kmers"
path = str(Path(utpath("big_legacy")).parent)
assert sum(1 for i in TracksDict(path).values()) > 2
assert {
Path(i.path).stem
for i in TracksDict(path, match="kmer").values()
} == {
'test035_5HPs_mix_CTGT--4xAc_5nM_25C_10sec',
'test035_5HPs_mix_GATG_5nM_25C_8sec_with_ramp'
}
assert len(
{Path(i.path).stem
for i in TracksDict(path, match="3mer").values()}) == 0
assert {
Path(i.path).stem
for i in TracksDict(path, match="4mer").values()
} == {
'test035_5HPs_mix_CTGT--4xAc_5nM_25C_10sec',
'test035_5HPs_mix_GATG_5nM_25C_8sec_with_ramp'
}
assert {
Path(i.path).stem
for i in TracksDict(path, match="ctgt").values()
} == {
'test035_5HPs_mix_CTGT--4xAc_5nM_25C_10sec',
}
assert {
Path(i.path).stem
for i in TracksDict(path, match="gatg").values()
} == {'test035_5HPs_mix_GATG_5nM_25C_8sec_with_ramp'}
cur = TracksDict(path, match="4mer")
assert ({
Path(i.path).stem
for i in TracksDict.leastcommonkeys(cur).values()
} == {
'test035_5HPs_mix_CTGT--4xAc_5nM_25C_10sec',
'test035_5HPs_mix_GATG_5nM_25C_8sec_with_ramp'
})
assert ({
Path(i.path).stem
for i in TracksDict.leastcommonkeys(*cur.values()).values()
} == {
'test035_5HPs_mix_CTGT--4xAc_5nM_25C_10sec',
'test035_5HPs_mix_GATG_5nM_25C_8sec_with_ramp'
})
assert ({
Path(i.path).stem
for i in TracksDict.leastcommonkeys(cur.values()).values()
} == {
'test035_5HPs_mix_CTGT--4xAc_5nM_25C_10sec',
'test035_5HPs_mix_GATG_5nM_25C_8sec_with_ramp'
})
