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_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_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_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_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_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_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_set_alphabet(self):
bp_form = core.BpForm()
bp_form.alphabet = dna.dna_alphabet
self.assertEqual(len(bp_form.alphabet), 4)
with self.assertRaises(ValueError):
bp_form.alphabet = None
with self.assertRaises(ValueError):
bp_form.alphabet = 'A'
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_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_set_bond_formula(self):
bp_form = core.BpForm()
bp_form.bond_formula = EmpiricalFormula('CHO')
self.assertEqual(bp_form.bond_formula, EmpiricalFormula('CHO'))
bp_form.bond_formula = 'CHO'
self.assertEqual(bp_form.bond_formula, EmpiricalFormula('CHO'))
with self.assertRaises(ValueError):
bp_form.bond_formula = '123'
with self.assertRaises(TypeError):
bp_form.bond_formula = 123
with self.assertRaises(TypeError):
bp_form.bond_formula = None
def test_set_bond_charge(self):
bp_form = core.BpForm()
bp_form.bond_charge = 1
self.assertEqual(bp_form.bond_charge, 1)
bp_form.bond_charge = 1.
self.assertEqual(bp_form.bond_charge, 1)
bp_form.bond_charge = -1
self.assertEqual(bp_form.bond_charge, -1)
with self.assertRaises(ValueError):
bp_form.bond_charge = 1.5
with self.assertRaises(ValueError):
bp_form.bond_charge = None
def test_protonate(self):
base_1 = core.Base(id='A')
base_2 = core.Base(id='B')
bp_form = core.BpForm([base_1, base_2])
bp_form.protonate(7.)
def test_len(self):
bp_form = core.BpForm()
self.assertEqual(len(bp_form), 0)
bp_form = core.BpForm(base_seq=[core.Base(), core.Base()])
self.assertEqual(len(bp_form), 2)
def test_init(self):
bp_form = core.BpForm()
self.assertEqual(bp_form.base_seq, core.BaseSequence())
self.assertEqual(bp_form.alphabet, {})
self.assertEqual(bp_form.bond_formula, EmpiricalFormula())
self.assertEqual(bp_form.bond_charge, 0)
