def test_thiostrepton(self):
def callback(outdir):
# make sure the html_output section was tested
with open(os.path.join(outdir, "index.html")) as handle:
content = handle.read()
assert "ACN52291.1 leader / core peptide, putative Type II" in content
genbank = path.get_full_path(__file__, 'data', 'thiostrepton_before_analysis.gbk')
result = helpers.run_and_regenerate_results_for_module(genbank, thiopeptides,
self.config, callback=callback)
result = helpers.run_and_regenerate_results_for_module(genbank, thiopeptides, self.config)
assert len(result.motifs) == 1
prepeptide = result.motifs[0]
# check prepeptide values
self.assertAlmostEqual(1639.6, prepeptide.monoisotopic_mass, places=1)
self.assertAlmostEqual(1640.9, prepeptide.molecular_weight, places=1)
assert prepeptide.leader == "MSNAALEIGVEGLTGLDVDTLEISDYMDETLLDGEDLTVTM"
assert prepeptide.core == "IASASCTTCICTCSCSS"
assert prepeptide.detailed_information.macrocycle == "26-member"
assert prepeptide.peptide_subclass == "Type II"
expected_features = ("Central ring: piperidine;"
" second macrocycle containing a quinaldic acid moiety")
assert prepeptide.detailed_information.core_features == expected_features
for calc, expect in zip(prepeptide.detailed_information.mature_weights,
[1646.8, 1645.5, 1664.8, 1682.8, 1700.8, 1718.8,
1736.9, 1754.9, 1772.9, 1790.9]):
self.assertAlmostEqual(calc, expect, places=1)
def test_regeneration(self):
datafile = helpers.get_path_to_balhymicin_genbank()
results = helpers.run_and_regenerate_results_for_module(
datafile, nrps_pks_domains, self.options)
assert results
assert len(results.cds_results) == 9
expected_types = {
'bpsC': 'NRPS',
'pks': 'other',
'bpsD': 'NRPS-like protein',
'dpgD': 'other',
'pgat': 'other',
'dpgB': 'other',
'bpsA': 'Glycopeptide NRPS',
'bpsB': 'Glycopeptide NRPS',
'dpgC': 'other'
}
for cds, cds_result in results.cds_results.items():
assert isinstance(cds_result,
nrps_pks_domains.domain_identification.CDSResult)
# motifs can be empty, but domains cannot be
assert cds_result.domain_hmms
assert cds_result.type
# ensure results were added as they regenerated, as it's a detection module
assert len(cds_result.domain_hmms) == len(cds.nrps_pks.domains)
assert len(cds_result.motif_hmms) == len(cds.motifs)
assert cds.nrps_pks.type == cds_result.type
found_types = {
cds.get_name(): result.type
for cds, result in results.cds_results.items()
}
assert found_types == expected_types
def test_lactazole(self):
"Test thiopeptide prediction for lactazole - lazA"
genbank = path.get_full_path(__file__, 'data', 'lac_before_analysis.gbk')
results = helpers.run_and_regenerate_results_for_module(genbank, thiopeptides, self.config)
assert len(results.motifs) == 1
rec = secmet.Record.from_genbank(genbank, "bacteria")[0]
before_count = rec.get_feature_count()
assert not rec.get_cds_motifs()
# add and check new motif added
results.add_to_record(rec)
assert rec.get_feature_count() == before_count + 1
assert len(rec.get_cds_motifs()) == 1
prepeptide = rec.get_cds_motifs()[0]
assert prepeptide is results.motifs[0]
# check prepeptide values
self.assertAlmostEqual(1362.5, prepeptide.monoisotopic_mass, places=1)
self.assertAlmostEqual(1363.5, prepeptide.molecular_weight, places=1)
assert prepeptide.leader == "MSDITASRVESLDLQDLDLSELTVTSLRDTVALPENGA"
assert prepeptide.core == "SWGSCSCQASSSCA"
assert not prepeptide.detailed_information.macrocycle
assert prepeptide.peptide_subclass == "Type III"
assert prepeptide.detailed_information.core_features == 'Central ring: pyridine trisubstituted'
assert prepeptide.tail == 'QPQDM'
for calc, expected in zip(prepeptide.alternative_weights,
[1381.5, 1399.5, 1417.5, 1435.5, 1453.6, 1471.6]):
self.assertAlmostEqual(calc, expected, places=1)
assert len(prepeptide.to_biopython()) == 3 # leader, core, tail
def test_CP009369(self): # pylint: disable=invalid-name
" tests the special case HMM files for rodeo "
config = build_config(["--minimal", "--enable-thiopeptides"],
isolated=True,
modules=antismash.get_all_modules())
record_path = path.get_full_path(__file__, 'data', 'CP009369.1.gbk')
results = helpers.run_and_regenerate_results_for_module(
record_path, thiopeptides, config)
assert results
assert len(results.motifs) == 1
prepeptide = results.motifs[0]
self.assertAlmostEqual(1934.6, prepeptide.monoisotopic_mass, places=1)
self.assertAlmostEqual(1936.0, prepeptide.molecular_weight, places=1)
assert prepeptide.leader == "MVKSIIKARESGRFYETKYLKGGEEMKEQKELKNEEFELDVEFLDLDEVSAIPETTA"
assert prepeptide.core == "SSGTSSCSASSTCGSSSCCGSC"
assert not prepeptide.macrocycle
assert prepeptide.peptide_subclass == "Type III"
assert prepeptide.core_features == 'Central ring: pyridine trisubstituted'
assert prepeptide.tail == ''
for calc, expected in zip(prepeptide.alternative_weights, [
1954.0, 1972.1, 1990.1, 2008.1, 2026.1, 2044.1, 2062.2, 2080.2,
2098.2, 2116.2, 2134.2, 2152.3, 2170.3
]):
self.assertAlmostEqual(calc, expected, places=1)
assert len(prepeptide.to_biopython()) == 2 # no tail
def test_cp002271_c19(self):
filename = path.get_full_path(__file__, 'data', 'CP002271.1.cluster019.gbk')
results = helpers.run_and_regenerate_results_for_module(filename, nrps_pks, self.options)
# catch ordering changes along with ensuring ATResults are there
pred = results.domain_predictions["nrpspksdomains_STAUR_3982_PKS_AT.1"]
assert pred["signature"].predictions[0][1].score == 87.5
# ensure all genes are present and have the right consensus
assert results.consensus == {'nrpspksdomains_STAUR_3982_PKS_AT.1': 'mmal',
'nrpspksdomains_STAUR_3983_PKS_AT.1': 'mmal',
'nrpspksdomains_STAUR_3984_PKS_AT.1': 'mmal',
'nrpspksdomains_STAUR_3985_PKS_AT.1': 'pk',
'nrpspksdomains_STAUR_3985_PKS_AT.2': 'mmal'}
assert len(results.region_predictions) == 1
assert list(results.region_predictions) == [1]
assert len(results.region_predictions[1]) == 1
# check the gene ordering and, in this case, that it used domain docking
sc_pred = results.region_predictions[1][0]
assert sc_pred.polymer == '(Me-ccmal) + (Me-ccmal) + (Me-ccmal)'
assert sc_pred.domain_docking_used
assert sc_pred.ordering == ['STAUR_3983', 'STAUR_3984', 'STAUR_3985', 'STAUR_3982']
assert len(results.domain_predictions) == 10
expected_domains = {'nrpspksdomains_STAUR_3982_PKS_AT.1',
'nrpspksdomains_STAUR_3983_PKS_AT.1',
'nrpspksdomains_STAUR_3984_PKS_AT.1',
'nrpspksdomains_STAUR_3985_PKS_AT.1',
'nrpspksdomains_STAUR_3985_PKS_AT.2',
'nrpspksdomains_STAUR_3972_PKS_KR.1',
'nrpspksdomains_STAUR_3984_PKS_KR.1',
'nrpspksdomains_STAUR_3985_PKS_KR.1',
'nrpspksdomains_STAUR_3983_PKS_KR.1',
'nrpspksdomains_STAUR_3983_PKS_KR.1',
'nrpspksdomains_STAUR_3982_PKS_KR.1'}
assert set(results.domain_predictions) == expected_domains
def test_nosiheptide(self):
"Test thiopeptide prediction for nosiheptide - nosM"
genbank = path.get_full_path(__file__, 'data', 'nosi_before_analysis.gbk')
result = helpers.run_and_regenerate_results_for_module(genbank, thiopeptides, self.config)
rec = secmet.Record.from_genbank(genbank, "bacteria")[0]
existing_feature_count = rec.get_feature_count()
assert result.motifs[0].peptide_subclass == "Type I"
assert not rec.get_cds_motifs()
assert rec.get_feature_count() == existing_feature_count
assert len(result.motifs) == 1
result.add_to_record(rec)
for i in rec.get_cds_motifs():
print(i, i.leader, i.score, i.detailed_information.rodeo_score)
assert len(rec.get_cds_motifs()) == 1, rec.get_cds_motifs()
assert rec.get_feature_count() == existing_feature_count + 1
# check the motif in an existing CDS
prepeptide = rec.get_cds_motifs()[0]
assert prepeptide is result.motifs[0]
self.assertAlmostEqual(1315.3, prepeptide.monoisotopic_mass, places=1)
self.assertAlmostEqual(1316.5, prepeptide.molecular_weight, places=1)
assert prepeptide.leader == "MDAAHLSDLDIDALEISEFLDESRLEDSEVVAKVMSA"
assert prepeptide.core == "SCTTCECCCSCSS"
assert prepeptide.detailed_information.macrocycle == "26-member"
assert prepeptide.peptide_subclass == "Type I"
for calc, expected in zip(prepeptide.detailed_information.mature_weights,
[1222.4, 1221.2, 1240.4, 1258.4, 1276.5, 1294.5, 1312.5, 1330.5]):
self.assertAlmostEqual(calc, expected, places=1)
expected_core_features = ("Central ring: pyridine tetrasubstituted (hydroxyl group present);"
" second macrocycle")
assert prepeptide.detailed_information.core_features == expected_core_features
assert prepeptide.detailed_information.amidation
def test_reuse(self):
nisin = helpers.get_path_to_nisin_genbank()
record = record_processing.parse_input_sequence(nisin)[0]
results = helpers.run_and_regenerate_results_for_module(
nisin, cluster_hmmer, self.options)
json = results.to_json()
assert len(results.hits) == 24
self.check_add_to_record(nisin, results)
# test regeneration when thresholds are less restrictive
new_score_threshold = self.original_min_score - .1
self.set_min_score(new_score_threshold)
new_results = cluster_hmmer.regenerate_previous_results(
json, record, self.options)
assert new_results is None
self.set_min_score(self.original_min_score)
new_evalue_threshold = self.original_max_evalue + .1
self.set_max_evalue(new_evalue_threshold)
new_results = cluster_hmmer.regenerate_previous_results(
json, record, self.options)
assert new_results is None
self.set_max_evalue(self.original_max_evalue)
# test regeneration when evalue threshold is more restrictive
new_evalue_threshold = sorted(hit["evalue"]
for hit in results.hits)[12]
assert new_evalue_threshold < self.original_max_evalue
new_hits = []
for hit in results.hits:
if hit["evalue"] <= new_evalue_threshold:
new_hits.append(hit)
new_hits.sort(key=lambda x: x["evalue"])
assert len(new_hits) < 24
self.set_max_evalue(new_evalue_threshold)
new_results = cluster_hmmer.regenerate_previous_results(
json, record, self.options)
self.set_max_evalue(self.original_max_evalue)
assert sorted(new_results.hits, key=lambda x: x["evalue"]) == new_hits
self.check_add_to_record(nisin, results)
# test regeneration when score threshold is more restrictive
new_score_threshold = sorted(hit["score"] for hit in results.hits)[12]
assert new_score_threshold > cluster_hmmer.MIN_SCORE
new_hits = []
for hit in results.hits:
if hit["score"] >= new_score_threshold:
new_hits.append(hit)
new_hits.sort(key=lambda x: x["score"])
assert len(new_hits) < 24
self.set_min_score(new_score_threshold)
new_results = cluster_hmmer.regenerate_previous_results(
json, record, self.options)
self.set_min_score(self.original_min_score)
assert sorted(new_results.hits, key=lambda x: x["score"]) == new_hits
self.check_add_to_record(nisin, results)
def test_nisin_end_to_end(self):
# skip fimo being disabled for this, we already test the computational
# side elsewhere
if self.options.without_fimo:
return
nisin = helpers.get_path_to_nisin_genbank()
result = helpers.run_and_regenerate_results_for_module(
nisin, lanthipeptides, self.options)
assert list(result.motifs_by_locus) == ["nisB"]
prepeptide = result.motifs_by_locus["nisB"][0]
self.assertAlmostEqual(3336.0, prepeptide.molecular_weight, delta=0.05)
def run_antismash(self, filename, expected):
with TemporaryDirectory() as output_dir:
update_config({"output_dir": output_dir})
results = helpers.run_and_regenerate_results_for_module(filename, clusterblast, self.options)
update_config({"output_dir": ""})
results, global_results = self.get_results(results)
assert len(results.region_results) == 1
cluster = results.region_results[0]
assert len(cluster.ranking) == expected # will change if database does
self.check_svgs(global_results, expected, output_dir)
return results
def test_balhymicin(self):
filename = helpers.get_path_to_balhymicin_genbank()
results = helpers.run_and_regenerate_results_for_module(filename, nrps_pks, self.options)
for key, val in results.pks.method_results.items():
if key != "minowa_cal":
assert not val
continue
assert len(val) == 1
assert len(val["nrpspksdomains_pks_CAL1"]) == 5
assert val["nrpspksdomains_pks_CAL1"][0] == ["AHBA", 167.0]
# when the NRPS subsections are added, this needs to change
assert results.nrps == {}
# as does this, though it still won't use domain docking
assert results.cluster_predictions == {'1': [
'(nrp-nrp-nrp) + (nrp-nrp-nrp) + (nrp) + (nrp) + (pk)', False]}
def test_nisin(self):
genbank = helpers.get_path_to_nisin_with_detection()
results = helpers.run_and_regenerate_results_for_module(genbank, rrefinder, self.options)
assert isinstance(results, rrefinder.RREFinderResults)
assert results.bitscore_cutoff == self.options.rre_cutoff
assert results.min_length == self.options.rre_min_length
assert results.record_id == 'HM219853.1'
assert len(results.features) == 1
feature = results.features[0]
assert feature.locus_tag == 'nisB'
assert feature.score == 34.9
assert feature.protein_location == FeatureLocation(141, 228)
assert feature.domain == 'Lanthipeptide_RRE'
assert feature.translation == 'FTRNNANYKFGDRVFQVYTINSSELEEVNIKYTNVYQIISEFC' +
'ENDYQKYEDICETVTLCYGDEYRELSEQYLGSLIVNHYLISNLQK'
def test_cp002271_c19(self):
filename = path.get_full_path(__file__, 'data', 'CP002271.1.cluster019.gbk')
results = helpers.run_and_regenerate_results_for_module(filename, nrps_pks, self.options)
# catch ordering changes along with ensuring ATResults are there
assert results.pks.method_results["signature"]["nrpspksdomains_STAUR_3982_AT1"][0].score == 87.5
# ensure all genes are present and have the right consensus
assert results.consensus == {'nrpspksdomains_STAUR_3982_AT1': 'ohmmal',
'nrpspksdomains_STAUR_3983_AT1': 'ccmmal',
'nrpspksdomains_STAUR_3984_AT1': 'ccmmal',
'nrpspksdomains_STAUR_3985_AT1': 'pk',
'nrpspksdomains_STAUR_3985_AT2': 'pk'}
# check the gene ordering and, in this case, that it used domain docking
assert results.cluster_predictions == {'1': [
'(ccmmal) + (ccmmal) + (pk-pk) + (ohmmal)', True]}
# no A domains in the cluster, so make sure no NRPS results
assert results.nrps == {}
def test_reuse(self):
test_file = path.get_full_path(__file__, 'data',
'NC_003888.3.cluster011.gbk')
results = helpers.run_and_regenerate_results_for_module(
test_file, t2pks, self.options)
assert list(results.cluster_predictions) == [1]
pred = results.cluster_predictions[1]
assert pred.starter_units == [
t2pks.results.Prediction('acetyl-CoA', 0., 0.)
]
assert pred.malonyl_elongations == [
t2pks.results.Prediction('7', 743.5, 1.2e-226)
]
assert pred.product_classes == {'benzoisochromanequinone'}
assert list(pred.molecular_weights) == ['acetyl-CoA_7']
self.assertAlmostEqual(pred.molecular_weights['acetyl-CoA_7'],
342.3845)
def test_balhymicin(self):
filename = helpers.get_path_to_balhymicin_genbank()
results = helpers.run_and_regenerate_results_for_module(
filename, nrps_pks, self.options)
assert len(results.domain_predictions) == 9
a_domains = [("bpsA", 1), ("bpsA", 2), ("bpsA", 3), ("bpsB", 1),
("bpsB", 2), ("bpsB", 3), ("bpsC", 1), ("bpsD", 1)]
nrps_names = [
'nrpspksdomains_%s_AMP-binding.%d' % a_dom for a_dom in a_domains
]
feature_names = nrps_names + ["nrpspksdomains_pks_CAL_domain.1"]
assert set(results.domain_predictions) == set(feature_names)
assert set(results.domain_predictions[feature_names[0]]) == {
"NRPSPredictor2"
}
nrpspred2_results = {}
for domain, methods in results.domain_predictions.items():
if "CAL" in domain:
continue
nrpspred2_results[domain] = methods[
"NRPSPredictor2"].get_classification()
expected_preds = [["leu"], ["bht"], ["asn"], ["hpg"], ["hpg"], ["bht"],
["dhpg"], ["tyr"], ["pk"]]
expected_nrps2 = {
name: pred
for name, pred in zip(nrps_names, expected_preds)
}
assert nrpspred2_results == expected_nrps2
cal = results.domain_predictions["nrpspksdomains_pks_CAL_domain.1"][
"minowa_cal"]
assert len(cal.predictions) == 5
assert cal.predictions[0] == ["AHBA", 167.0]
assert len(results.region_predictions[1]) == 2
# as does this, though it still won't use domain docking
pred = results.region_predictions[1][0]
monomers = '(leu - bht - asn) + (hpg - hpg - bht) + (dhpg) + (tyr) + (pk)'
assert pred.polymer == monomers
assert not pred.domain_docking_used
pred = results.region_predictions[1][1]
assert pred.polymer == "(tyr) + (pk)"
assert not pred.domain_docking_used
def test_reuse(self):
nisin = helpers.get_path_to_nisin_genbank()
results = helpers.run_and_regenerate_results_for_module(
nisin, pfam2go, self.options)
# are the expected go ids for pfams found/no wrong ids for pfams?
expected_pfams_and_gos_with_descs = {
"PF00005": {
"GO:0005524": "ATP binding",
"GO:0016887": "ATPase activity"
},
"PF00072": {
"GO:0000160": "phosphorelay signal transduction system"
},
"PF00486": {
"GO:0003677": "DNA binding",
"GO:0000160": "phosphorelay signal transduction system",
"GO:0006355": "regulation of transcription, DNA-templated"
}
}
expected_pfams_found = set()
for pfam, all_ontologies in results.pfam_domains_with_gos.items():
pfam_ids_without_versions = [
pfam_id.partition(".")[0] for pfam_id in pfam.db_xref
]
# make sure the Pfams without gos aren't in the results
assert "PF05147" not in pfam_ids_without_versions and "PF04738" not in pfam_ids_without_versions
for ontologies in all_ontologies:
# make sure GeneOntologies' pfam id actually is one found in the domain's ids
assert ontologies.pfam in pfam_ids_without_versions
# did it find the right amount of GO IDs for the sample Pfams, and did it find the right ones?
if ontologies.pfam in expected_pfams_and_gos_with_descs:
expected_pfams_found.add(ontologies.pfam)
go_ids = [
str(go_entry) for go_entry in ontologies.go_entries
]
assert len(go_ids) == len(
expected_pfams_and_gos_with_descs[ontologies.pfam])
for go_id in go_ids:
assert go_id in expected_pfams_and_gos_with_descs[
ontologies.pfam]
# make sure all expected pfams have been found
assert len(expected_pfams_found) == len(
expected_pfams_and_gos_with_descs)
self.check_add_to_record(nisin, results)
def test_full(self):
assert cluster_compare.is_enabled(self.options)
input_path = helpers.get_path_to_balhymicin_genbank()
results = helpers.run_and_regenerate_results_for_module(input_path, cluster_compare, self.options)
proto = results.by_database["MIBiG"].by_region[1]["ProtoToRegion_RiQ"]
# ordering should be correct
assert proto.scores_by_region[0][1] > proto.scores_by_region[1][1]
# check the winner makes sense for proto to region, the value won't be 1.0
assert proto.scores_by_region[0][0].accession == "BGC0000311.1"
self.assertAlmostEqual(proto.scores_by_region[0][1], 1.80874, places=5)
region = results.by_database["MIBiG"].by_region[1]["RegionToRegion_RiQ"]
# ordering should be correct
assert region.scores_by_region[0][1] > region.scores_by_region[1][1]
# again, check the winner, but this time it *should* be 1.0 as there's no protoclusters used
assert region.scores_by_region[0][0].accession == "BGC0000311.1", region.scores_by_region
self.assertAlmostEqual(region.scores_by_region[0][1], 1.0, places=5)
def test_regeneration(self):
datafile = helpers.get_path_to_balhymicin_genbank()
results = helpers.run_and_regenerate_results_for_module(
datafile, active_site_finder, self.options)
assert results.pairings
for domain, labels in results.pairings:
for label in labels:
assert label
assert isinstance(label, str)
assert isinstance(domain, secmet.AntismashDomain)
record = parse_input_sequence(datafile)
# check the reuse portion works
rerun = active_site_finder.run_on_record(record, results, self.options)
assert rerun is results # specifically checking it's the same object
with self.assertRaisesRegex(AssertionError, "str"):
active_site_finder.run_on_record(record, "invalid", self.options)
def test_thiostrepton_full(self):
def callback(outdir):
# make sure the html_output section was tested
with open(os.path.join(outdir, "index.html")) as handle:
content = handle.read()
assert "ACN52291.1 leader / core peptide, putative Type II" in content
config = build_config(["--minimal", "--enable-thiopeptides"],
isolated=True,
modules=antismash.get_all_modules())
record_path = path.get_full_path(__file__, 'data',
'thiostrepton_before_analysis.gbk')
regenned_results = helpers.run_and_regenerate_results_for_module(
record_path, thiopeptides, config, callback=callback)
assert regenned_results
assert len(regenned_results.motifs) == 1
self.check_thiostrepton_values(regenned_results.motifs[0])
def run_lanthi(self, genbank, html_snippet, expected_motifs=1):
def callback(output_dir):
with open(os.path.join(output_dir, "index.html")) as handle:
content = handle.read()
assert html_snippet in content
rec = Record.from_genbank(genbank, taxon="bacteria")[0]
assert not rec.get_cds_motifs()
result = helpers.run_and_regenerate_results_for_module(
genbank, lanthipeptides, self.options, callback=callback)
assert len(result.clusters) == 1
motifs = self.gather_all_motifs(result)
assert len(motifs) == expected_motifs
result.add_to_record(rec)
assert len(rec.get_cds_motifs()) == expected_motifs
return rec, result
def test_full_blastp_use(self):
test_file = path.get_full_path(__file__, 'data', 'GQ409537.1.gbk')
results = helpers.run_and_regenerate_results_for_module(
test_file, t2pks, self.options)
assert list(results.cluster_predictions) == [1]
pred = results.cluster_predictions[1]
assert pred.starter_units == [
t2pks.results.Prediction('malonamyl-CoA', 2319., 0.)
]
assert pred.malonyl_elongations == [
t2pks.results.Prediction('8|9', 661.0, 1.3e-201)
]
assert pred.product_classes == {
'angucycline', 'tetracycline', 'aureolic acid', 'anthracycline'
}
assert set(
pred.molecular_weights) == {'malonamyl-CoA_8', 'malonamyl-CoA_9'}
self.assertAlmostEqual(pred.molecular_weights['malonamyl-CoA_8'],
638.63534)
self.assertAlmostEqual(pred.molecular_weights['malonamyl-CoA_9'],
680.67202)
def test_NZ_CP015439(self): # pylint: disable=invalid-name
""" Tests that small ORFs are found and saved in results """
record_path = path.get_full_path(__file__, 'data',
'NZ_CP015439_section.gbk')
results = helpers.run_and_regenerate_results_for_module(
record_path, thiopeptides, self.config)
assert results
# check that the extra orf was found and stored correctly
assert len(results.cds_features) == 1
additions = list(results.cds_features.values())[0]
assert len(additions) == 1
assert isinstance(additions[0], secmet.features.CDSFeature)
# also test the analysis results itself
assert len(results.motifs) == 1
prepeptide = results.motifs[0]
self.assertAlmostEqual(1408.6, prepeptide.monoisotopic_mass, places=1)
self.assertAlmostEqual(1409.5, prepeptide.molecular_weight, places=1)
assert prepeptide.leader == "MRYMEGGENMQDIMLELYAEELPDITQYTAAGTSTLSTESSVLSASCP"
assert prepeptide.core == "TSTASTYTSMSSVS"
def test_reuse(self):
raw_results = sideloader.loader.load_validated_json(
GOOD_FILE, sideloader.general._SCHEMA_FILE)
nisin = helpers.get_path_to_nisin_genbank()
results = helpers.run_and_regenerate_results_for_module(
nisin, sideloader, self.options)
assert results.record_id == raw_results["records"][0]["name"]
record_section = raw_results["records"][0]
for result, raw in zip(results.subregions,
record_section["subregions"]):
assert result.tool.name == raw_results["tool"]["name"]
assert result.start == raw["start"]
assert result.end == raw["end"]
assert result.label == raw["label"]
assert result.details == {
"score": ["6.5"],
"some_option_name": ["yes"],
"some_other_detail": ["first", "second", "etc"]
}
def run_analysis(self, filename):
datafile = path.get_full_path(__file__, "data", filename)
return helpers.run_and_regenerate_results_for_module(datafile, lassopeptides, self.options)
