def test_get_formula_mol_wt_charge(self):
base_A = core.Base(id='A', structure=dAMP_inchi)
base_C = core.Base(id='C', structure=dCMP_inchi)
bp_form = core.BpForm([base_A])
self.assertEqual(bp_form.get_formula(), base_A.get_formula())
self.assertEqual(bp_form.get_mol_wt(), base_A.get_mol_wt())
self.assertEqual(bp_form.get_charge(), base_A.get_charge())
bp_form = core.BpForm([base_C])
self.assertEqual(bp_form.get_formula(), base_C.get_formula())
self.assertEqual(bp_form.get_mol_wt(), base_C.get_mol_wt())
self.assertEqual(bp_form.get_charge(), base_C.get_charge())
bp_form = core.BpForm([base_A, base_C])
self.assertEqual(bp_form.get_formula(), base_A.get_formula() + base_C.get_formula())
self.assertEqual(bp_form.get_mol_wt(), base_A.get_mol_wt() + base_C.get_mol_wt())
self.assertEqual(bp_form.get_charge(), base_A.get_charge() + base_C.get_charge())
bp_form = core.BpForm([base_A, base_C], bond_formula=EmpiricalFormula('H') * -1, bond_charge=1)
self.assertEqual(bp_form.get_formula(), base_A.get_formula() + base_C.get_formula() - EmpiricalFormula('H'))
self.assertEqual(bp_form.get_mol_wt(), base_A.get_mol_wt() + base_C.get_mol_wt() -
EmpiricalFormula('H').get_molecular_weight())
self.assertEqual(bp_form.get_charge(), base_A.get_charge() + base_C.get_charge() + 1)
bp_form = core.BpForm([base_A, base_A, base_C, base_C, base_C], bond_formula=EmpiricalFormula('H') * -1, bond_charge=1)
self.assertEqual(bp_form.get_formula(), base_A.get_formula() * 2 + base_C.get_formula() * 3 - EmpiricalFormula('H') * 4)
self.assertEqual(bp_form.get_mol_wt(), base_A.get_mol_wt() * 2 + base_C.get_mol_wt()
* 3 - EmpiricalFormula('H').get_molecular_weight() * 4)
self.assertEqual(bp_form.get_charge(), base_A.get_charge() * 2 + base_C.get_charge() * 3 + 1 * 4)
def test_append(self):
seq = core.BaseSequence()
seq.append(core.Base())
seq.append(core.Base())
self.assertEqual(len(seq), 2)
with self.assertRaises(ValueError):
seq.append('A')
def test_protonate(self):
base = core.Base()
base.protonate(7.)
base = core.Base(structure=dAMP_inchi)
base.protonate(7.)
base.protonate(10.)
def test_delitem(self):
base_1 = core.Base(id='A')
base_2 = core.Base(id='B')
base_3 = core.Base(id='C')
bp_form = core.BpForm([base_1, base_2, base_3])
del(bp_form[1])
self.assertTrue(bp_form.is_equal(core.BpForm([base_1, base_3])))
def test_getitem(self):
base_1 = core.Base(id='A')
base_2 = core.Base(id='B')
base_3 = core.Base(id='C')
bp_form = core.BpForm([base_1, base_2, base_3])
self.assertEqual(bp_form[0], base_1)
self.assertEqual(bp_form[1], base_2)
self.assertEqual(bp_form[0:1], [base_1])
def test_contains(self):
base_1 = core.Base(id='A')
base_2 = core.Base(id='B')
base_3 = core.Base(id='C')
bp_form = core.BpForm([base_1, base_2])
self.assertIn(base_1, bp_form)
self.assertIn(base_2, bp_form)
self.assertNotIn(base_3, bp_form)
def test_get_mol_wt(self):
base = core.Base()
self.assertEqual(base.get_mol_wt(), None)
base = core.Base(structure=dAMP_inchi)
self.assertEqual(base.get_mol_wt(), 329.208761998)
base.delta_mass = 1.
self.assertEqual(base.get_mol_wt(), 330.208761998)
def test_get_base_counts(self):
base_1 = core.Base(id='A')
base_2 = core.Base(id='B')
base_3 = core.Base(id='C')
bp_form = core.BpForm([base_1, base_2, base_1, base_1, base_1, base_2, base_2, base_3])
self.assertEqual(bp_form.get_base_counts(), {
base_1: 4,
base_2: 3,
base_3: 1,
})
def test_get_base_counts(self):
base_1 = core.Base(id='A')
base_2 = core.Base(id='A')
base_3 = core.Base(id='A')
seq = core.BaseSequence([base_1, base_2, base_3, base_3, base_3, base_2, base_2, base_3])
self.assertEqual(seq.get_base_counts(), {
base_1: 1,
base_2: 3,
base_3: 4,
})
def test_get_charge(self):
base = core.Base()
self.assertEqual(base.get_charge(), None)
base = core.Base(structure=dAMP_inchi)
self.assertEqual(base.get_charge(), -2)
base = core.Base(structure=dAMP_inchi)
base.delta_charge = 1
self.assertEqual(base.get_charge(), -1)
def test_reversed(self):
base_1 = core.Base(id='A')
base_2 = core.Base(id='B')
base_3 = core.Base(id='C')
bp_form = core.BpForm([base_1, base_2, base_3])
for i_base, base in enumerate(reversed(bp_form)):
if i_base == 2:
self.assertEqual(base, base_1)
if i_base == 1:
self.assertEqual(base, base_2)
if i_base == 0:
self.assertEqual(base, base_3)
def test_init(self):
seq = core.BaseSequence(None)
seq = core.BaseSequence()
self.assertEqual(len(seq), 0)
seq = core.BaseSequence([core.Base(), core.Base()])
self.assertEqual(len(seq), 2)
with self.assertRaises(ValueError):
core.BaseSequence('A')
with self.assertRaises(ValueError):
core.BaseSequence(['A'])
def test_is_equal(self):
base_1 = core.Base(id='A', structure=dAMP_inchi)
base_2 = core.Base(id='A', structure=dAMP_inchi)
base_3 = core.Base(id='B', structure=dAMP_inchi)
base_4 = core.Base(id='A', structure=dCMP_inchi)
self.assertTrue(base_1.is_equal(base_1))
self.assertTrue(base_1.is_equal(base_2))
self.assertTrue(base_2.is_equal(base_1))
self.assertFalse(base_1.is_equal(mock.Mock(id='A', structure=dAMP_inchi)))
self.assertFalse(base_1.is_equal(base_3))
self.assertFalse(base_1.is_equal(base_4))
def test_setitem(self):
base_1 = core.Base(id='A')
base_2 = core.Base(id='B')
base_3 = core.Base(id='C')
bp_form = core.BpForm([base_1, base_2, base_3])
self.assertEqual(bp_form[0], base_1)
bp_form[0] = base_2
self.assertEqual(bp_form[0], base_2)
bp_form[0:1] = [base_3]
self.assertEqual(bp_form[0], base_3)
def test_set_base_seq(self):
bp_form = core.BpForm()
bp_form.base_seq = core.BaseSequence()
self.assertEqual(len(bp_form.base_seq), 0)
bp_form.base_seq = [core.Base(), core.Base()]
self.assertIsInstance(bp_form.base_seq, core.BaseSequence)
self.assertEqual(len(bp_form.base_seq), 2)
with self.assertRaises(ValueError):
bp_form.base_seq = None
with self.assertRaises(ValueError):
bp_form.base_seq = 'A'
def test_is_equal(self):
bp_form_1 = core.BpForm(base_seq=core.BaseSequence([core.Base(id='A'), core.Base(id='B')]))
bp_form_2 = core.BpForm(base_seq=core.BaseSequence([core.Base(id='A'), core.Base(id='B')]))
bp_form_3 = None
bp_form_4 = core.BpForm(base_seq=core.BaseSequence([core.Base(id='A'), core.Base(id='B')]), alphabet=dna.dna_alphabet)
bp_form_5 = core.BpForm(base_seq=core.BaseSequence([core.Base(id='A'), core.Base(id='B')]), bond_charge=-1)
bp_form_6 = core.BpForm(base_seq=core.BaseSequence(
[core.Base(id='A'), core.Base(id='B')]), bond_formula=EmpiricalFormula('H'))
self.assertTrue(bp_form_1.is_equal(bp_form_1))
self.assertTrue(bp_form_1.is_equal(bp_form_2))
self.assertFalse(bp_form_1.is_equal(bp_form_3))
self.assertFalse(bp_form_1.is_equal(bp_form_4))
self.assertFalse(bp_form_1.is_equal(bp_form_5))
self.assertFalse(bp_form_1.is_equal(bp_form_6))
def test_str(self):
base_A = core.Base(id='A', structure=dAMP_inchi)
base_C = core.Base(id='C', structure=dCMP_inchi)
base_G = core.Base(id='G', structure=dGMP_inchi)
bp_form = core.BpForm([base_A, base_C, base_G, base_A])
self.assertEqual(str(bp_form), '{}{}{}{}'.format(str(base_A), str(base_C), str(base_G), str(base_A)))
bp_form = core.BpForm([base_A, base_C, base_G, base_A], alphabet=core.Alphabet({
'A': base_A,
'C': base_C,
}))
self.assertEqual(str(bp_form), '{}{}{}{}'.format('A', 'C', str(base_G), 'A'))
self.assertEqual(str(bp_form), '{}{}{}{}'.format('A', 'C', '[id: "{}" | structure: {}]'.format('G', dGMP_inchi), 'A'))
def test_setitem(self):
seq = core.BaseSequence([core.Base(), core.Base()])
seq[0] = core.Base()
seq[0:1] = [core.Base()]
seq[0:1] = core.BaseSequence([core.Base()])
with self.assertRaises(ValueError):
seq[0] = 'A'
with self.assertRaises(ValueError):
seq[0] = ['A']
with self.assertRaises(ValueError):
seq[0:1] = 'A'
with self.assertRaises(ValueError):
seq[0:1] = ['A']
def test_delta_mass_setter(self):
base = core.Base()
base.delta_mass = None
base.delta_mass = 1
base.delta_mass = 1.
with self.assertRaises(ValueError):
base.delta_mass = 'a'
def test_str(self):
base = core.Base()
base.id = 'dAMP'
self.assertEqual(str(base), '[id: "dAMP"]')
base.name = 'deoxyadenosine monophosphate'
self.assertEqual(str(base), '[id: "dAMP" | name: "deoxyadenosine monophosphate"]')
base.synonyms = set(['A', 'dAMP'])
self.assertIn(' | synonym: "A"', str(base))
self.assertIn(' | synonym: "dAMP"', str(base))
base.identifiers = set([core.Identifier('chebi', 'CHEBI:58245'), core.Identifier('biocyc.compound', 'DAMP')])
self.assertIn(' | identifier: chebi/CHEBI:58245', str(base))
self.assertIn(' | identifier: biocyc.compound/DAMP', str(base))
base.structure = dAMP_inchi
self.assertIn(' | structure: {}]'.format(dAMP_inchi), str(base))
base.delta_mass = 1.
base.delta_charge = -1
self.assertIn(' | delta-mass: 1', str(base))
self.assertIn(' | delta-charge: -1', str(base))
base.start_position = 3
self.assertIn(' | position: 3-]', str(base))
base.end_position = 5
self.assertIn(' | position: 3-5]', str(base))
base.start_position = None
self.assertIn(' | position: -5]', str(base))
base.comments = 'help "me"'
self.assertIn(' | comments: "help \\"me\\""', str(base))
def test_id_setter(self):
base = core.Base()
base.id = None
base.id = ''
base.id = 'A'
with self.assertRaises(ValueError):
base.id = 1
def test_name_setter(self):
base = core.Base()
base.name = None
base.name = ''
base.name = 'A'
with self.assertRaises(ValueError):
base.name = 1
def test_delta_charge_setter(self):
base = core.Base()
base.delta_charge = None
base.delta_charge = 1
base.delta_charge = 1.
with self.assertRaises(ValueError):
base.delta_charge = 1.5
with self.assertRaises(ValueError):
base.delta_charge = 'a'
def test_synonyms_setter(self):
base = core.Base()
base.synonyms = core.SynonymSet()
base.synonyms = set(['A'])
base.synonyms = ['A']
with self.assertRaises(ValueError):
base.synonyms = None
with self.assertRaises(ValueError):
base.synonyms = 'A'
def test_identifiers_setter(self):
base = core.Base()
base.identifiers = core.IdentifierSet()
base.identifiers = set([core.Identifier('ns', 'id')])
base.identifiers = [core.Identifier('ns', 'id')]
with self.assertRaises(ValueError):
base.identifiers = None
with self.assertRaises(ValueError):
base.identifiers = 'A'
with self.assertRaises(TypeError):
base.identifiers = core.Identifier('ns', 'id')
def test_end_position_setter(self):
base = core.Base()
base.end_position = None
base.end_position = 1
base.end_position = 1.
with self.assertRaises(ValueError):
base.end_position = 1.5
with self.assertRaises(ValueError):
base.end_position = -1
with self.assertRaises(ValueError):
base.end_position = 'a'
def test_is_equal(self):
seq_1 = core.BaseSequence([core.Base(id='A'), core.Base(id='B')])
seq_2 = core.BaseSequence([core.Base(id='A'), core.Base(id='B')])
seq_3 = core.BaseSequence([core.Base(id='A'), core.Base(id='C')])
self.assertTrue(seq_1.is_equal(seq_1))
self.assertTrue(seq_1.is_equal(seq_2))
self.assertFalse(seq_1.is_equal([]))
self.assertFalse(seq_1.is_equal(seq_3))
def test_structure_setter(self):
base = core.Base()
base.structure = dAMP_inchi
ob_mol = openbabel.OBMol()
conversion = openbabel.OBConversion()
conversion.SetInFormat('inchi')
conversion.ReadString(ob_mol, dAMP_inchi)
base.structure = ob_mol
base.structure = ''
base.structure = None
with self.assertRaises(ValueError):
base.structure = 'InChI'
def test_init(self):
identifiers = set([
core.Identifier('chebi', 'CHEBI:58245'),
core.Identifier('pubchem.compound', '22848660'),
core.Identifier('metacyc.compound', 'DAMP'),
])
synonyms = set(['A', 'dAMP', 'deoxyadenosine monophosphate'])
base = core.Base(id='dAMP', name='deoxyadenosine monophosphate', synonyms=synonyms, identifiers=identifiers,
structure=dAMP_inchi, delta_mass=1., delta_charge=-1, start_position=2, end_position=10, comments='Long string')
self.assertEqual(base.id, 'dAMP')
self.assertEqual(base.name, 'deoxyadenosine monophosphate')
self.assertEqual(base.synonyms, synonyms)
self.assertEqual(base.identifiers, identifiers)
self.assertEqual(base.get_inchi(), dAMP_inchi)
self.assertEqual(base.delta_mass, 1.)
self.assertEqual(base.delta_charge, -1)
self.assertEqual(base.start_position, 2)
self.assertEqual(base.end_position, 10)
self.assertEqual(base.comments, 'Long string')
def test_protonate(self):
alphabet = core.Alphabet({
'A': core.Base(structure=dAMP_inchi),
'A': core.Base(structure=dCMP_inchi),
})
alphabet.protonate(7.)
