def describe_entity(entity: ChebiEntity) -> None:
"""
Test function to describe a ChEBI entity.
Args:
entity:
a :class:`ChebiEntity`
"""
name = entity.get_name()
out_lines = [] # type: List[str]
for other in entity.get_outgoings():
target = ChebiEntity(other.get_target_chebi_id())
out_lines.append(
f" • {name} {other.get_type()} {brief_description(target)}")
in_lines = [] # type: List[str]
for other in entity.get_incomings():
target = ChebiEntity(other.get_target_chebi_id())
in_lines.append(
f" • {brief_description(target)} {other.get_type()} {name}")
lines = ([entity.get_name(), f" ► OUTGOING ({len(out_lines)})"] +
out_lines + [f" ► INCOMING ({len(in_lines)})"] + in_lines)
report = "\n".join(lines)
log.info(f"{entity.get_id()}:\n{report}")
def has_roles(self):
if self.chebi_id:
entity = ChebiEntity('CHEBI:' + str(self.chebi_id))
outdict = dict()
for relation in entity.get_outgoings():
if relation.get_type() == 'has_role':
tid = relation.get_target_chebi_id()
t = ChebiEntity(tid)
s = re.findall(r'\d+', tid)
outdict[t.get_name()] = int(s[0])
return outdict
else:
return ''
def save_model(self, request, obj, form, change):
if form.cleaned_data['chebi_id']:
chebi_id = form.cleaned_data['chebi_id']
chebi_comb = ChebiEntity('CHEBI:' + str(chebi_id))
parent_id = chebi_comb.get_parent_id()
if parent_id:
s = re.findall(r'\d+', parent_id)
chebi_id = int(s[0])
chebi_comb = ChebiEntity('CHEBI:' + str(chebi_id))
obj.chebi_id = chebi_id
obj.chebi_name = chebi_comb.get_name()
else:
obj.chebi_name = None
if form.cleaned_data['pubchem_id']:
comp = Compound.from_cid(form.cleaned_data['pubchem_id'])
obj.pubchem_name = comp.synonyms[0]
else:
obj.pubchem_name = None
obj.save()
def check_entity_for_carboxylate(entity):
"""Check an entity from libchebipy for carboxylic acid. Returns
name of the protonated form.
The 'ate' term will also handle phosphates - so add check for that.
"""
# Using libchebipy -- Online:
name = entity.get_name()
outgoings = entity.get_outgoings()
smiles = entity.get_smiles()
if smiles is not None and has_carboxylate(smiles) is False:
return None, None
for out in outgoings:
type = out.get_type()
id = out.get_target_chebi_id()
if type == 'is_conjugate_base_of':
# use regular expression to remove any non alphabetic
# characters
# that may follow the name
only_alph = sub('[^A-Za-z]', '', name)
if only_alph[-3:] == 'ate' and only_alph[-5:] != 'phate':
acid_ID = id.replace("CHEBI:", "")
acid_entity = ChebiEntity(acid_ID)
acid_name = acid_entity.get_name()
# check if new SMILES is charged - don't change if it
# is
acid_smiles = acid_entity.get_smiles()
if acid_smiles is None:
continue
# confirm acid smiles has carboxylate based on SMILES
# string
if has_carboxylate(acid_smiles) is False:
continue
print('>>> new SMILES:', acid_smiles)
if check_charge_on_SMILES(acid_smiles):
if charge_except(acid_smiles) is False:
continue
print(acid_name, acid_entity)
print('---- Conjugate base of:', acid_name, '<<<<<<<<<<')
return acid_name, acid_entity
return None, None
def conditionclass(request, class_id):
class_entity = ChebiEntity('CHEBI:' + str(class_id))
class_name = class_entity.get_name()
children = []
for relation in class_entity.get_incomings():
if relation.get_type() == 'has_role':
tid = relation.get_target_chebi_id()
tid = re.search('(?<=CHEBI:)(\d)*', tid)
tid = int(tid.group(0))
children.append(tid)
conditiontypes = ConditionType.objects.filter(chebi_id__in=children)
datasets = Dataset.objects.filter(conditionset__conditions__type__in=conditiontypes)\
.exclude(paper__latest_data_status__status__name='not relevant').distinct()
return render(
request, 'conditions/class.html', {
'id': class_id,
'class_name': class_name,
'conditiontypes': conditiontypes,
'papers': datasets,
'DOWNLOAD_PREFIX': settings.DOWNLOAD_PREFIX,
'USER_AUTH': request.user.is_authenticated()
})
def check_line_for_carboxylate(line):
"""Check a line from the CHEBI compounds file for carboxylic acid.
Returns name of the protonated form.
"""
# USING OFFLINE FILE -- NOT COMPLETE
# ID, _, _, _, parent_id, name, notes, _, _, star = line
# print(name)
# print(notes)
# if 'Conjugate base of ' in notes:
# if name[-3:] == 'ate':
# acid_name = notes.replace("Conjugate base of ", '')
# acid_name = acid_name.split('acid')[0] + 'acid'
# print('Conjugate base of:', acid_name, '<<<<<<<<<<')
# return acid_name
# Using libchebipy -- Online:
ID, _, _, _, parent_id, name, notes, _, _, star = line
entity = ChebiEntity(ID)
outgoings = entity.get_outgoings()
for out in outgoings:
type = out.get_type()
id = out.get_target_chebi_id()
if type == 'is_conjugate_base_of':
print(out)
# use regular expression to remove any non alphabetic
# characters
# that may follow the name
only_alph = sub('[^A-Za-z]', '', name)
print(only_alph)
if only_alph[-3:] == 'ate' and only_alph[-5:] != 'phate':
acid_ID = id.replace("CHEBI:", "")
print('acid ID:', acid_ID)
acid_entity = ChebiEntity(acid_ID)
acid_name = acid_entity.get_name()
print('Conjugate base of:', acid_name, '<<<<<<<<<<')
return acid_name
return None
class TestChebiEntity(unittest.TestCase):
'''COMMENT'''
def setUp(self):
'''COMMENT'''
self.__existing = ChebiEntity('4167')
self.__secondary = ChebiEntity('CHEBI:5585')
def test_get_non_existing(self):
'''COMMENT'''
self.assertRaises(ChebiException, ChebiEntity, '-1')
def test_get_id_existing(self):
'''COMMENT'''
self.assertTrue(self.__existing.get_id() == 'CHEBI:4167')
def test_get_id_secondary(self):
'''COMMENT'''
self.assertTrue(self.__secondary.get_id() == 'CHEBI:5585')
def test_get_formulae_existing(self):
'''COMMENT'''
this_formula = Formula('C6H12O6', 'KEGG COMPOUND')
self.assertTrue(this_formula in self.__existing.get_formulae())
def test_get_formulae_secondary(self):
'''COMMENT'''
this_formula = Formula('H2O', 'ChEBI')
self.assertTrue(this_formula in self.__secondary.get_formulae())
def test_get_formula_existing(self):
'''COMMENT'''
self.assertTrue(self.__existing.get_formula() == 'C6H12O6')
def test_get_formula_secondary(self):
'''COMMENT'''
self.assertTrue(self.__secondary.get_formula() == 'H2O')
def test_get_mass_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_mass(), 180.15588)
def test_get_mass_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_mass(), 18.01530)
def test_get_charge_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_charge(), 0)
def test_get_charge_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_charge(), 0)
def test_get_charge_secondary2(self):
'''COMMENT'''
self.assertEquals(-2, ChebiEntity('43474').get_charge())
def test_get_comments_existing(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('29044')
this_comment = Comment('General', 'General',
'The substituent name \'3-oxoprop-2-enyl\' is '
'incorrect but is used in various databases.',
datetime.datetime.strptime('2005-03-18',
'%Y-%M-%d'))
self.assertTrue(this_comment in this_chebi_entity.get_comments())
def test_get_comments_secondary(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('11505')
this_comment = Comment('General', 'General',
'The substituent name \'3-oxoprop-2-enyl\' is '
'incorrect but is used in various databases.',
datetime.datetime.strptime('2005-03-18',
'%Y-%M-%d'))
self.assertTrue(this_comment in this_chebi_entity.get_comments())
def test_get_source_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_source(), 'KEGG COMPOUND')
def test_get_source_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_source(), 'KEGG COMPOUND')
def test_get_prnt_id_existing(self):
'''COMMENT'''
self.assertIsNone(self.__existing.get_parent_id())
def test_get_prnt_id_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_parent_id(), 'CHEBI:15377')
def test_get_name_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_name(), 'D-glucopyranose')
def test_get_name_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_name(), 'water')
def test_get_definition_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_definition(),
'A glucopyranose having D-configuration.')
def test_get_definition_secondary(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('41140')
self.assertEqual(this_chebi_entity.get_definition(),
'D-Glucopyranose with beta configuration at the '
'anomeric centre.')
def test_get_mod_on_existing(self):
'''COMMENT'''
self.assertTrue(self.__existing.get_modified_on() >
datetime.datetime.strptime('2014-01-01',
'%Y-%M-%d'))
def test_get_mod_on_secondary(self):
'''COMMENT'''
self.assertIsNotNone(self.__secondary.get_modified_on())
def test_get_created_by_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_created_by(), 'CHEBI')
def test_get_created_by_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_created_by(), 'ops$mennis')
def test_get_star_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_star(), 3)
def test_get_star_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_star(), 3)
def test_get_db_acc_existing(self):
'''COMMENT'''
dat_acc = DatabaseAccession('MetaCyc accession', 'D-Glucose',
'MetaCyc')
self.assertTrue(dat_acc in self.__existing.get_database_accessions())
def test_get_db_acc_secondary(self):
'''COMMENT'''
dat_acc = DatabaseAccession('MetaCyc accession', 'WATER', 'MetaCyc')
self.assertTrue(dat_acc in self.__secondary.get_database_accessions())
def test_get_inchi_existing(self):
'''COMMENT'''
inchi = 'InChI=1S/C6H12O6/c7-1-2-3(8)4(9)5(10)6(11)12-2/' + \
'h2-11H,1H2/t2-,3-,4+,5-,6?/m1/s1'
self.assertEqual(self.__existing.get_inchi(), inchi)
def test_get_inchi_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_inchi(), 'InChI=1S/H2O/h1H2')
def test_get_inchi_key_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_inchi_key(),
'WQZGKKKJIJFFOK-GASJEMHNSA-N')
def test_get_inchi_key_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_inchi_key(),
'XLYOFNOQVPJJNP-UHFFFAOYSA-N')
def test_get_smiles_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_smiles(),
'OC[C@H]1OC(O)[C@H](O)[C@@H](O)[C@@H]1O')
def test_get_smiles_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_smiles(), '[H]O[H]')
def test_get_mol_existing(self):
'''COMMENT'''
chebi_id = 73938
this_chebi_entity = ChebiEntity(str(chebi_id))
self.assertEqual(this_chebi_entity.get_mol(),
_read_mol_file(chebi_id))
def test_get_mol_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_mol(), _read_mol_file(15377))
def test_get_mol_file_existing(self):
'''COMMENT'''
chebi_id = 73938
self.__get_mol_file(chebi_id, chebi_id)
def test_get_mol_file_secondary(self):
'''COMMENT'''
read_id = 15377
retrieved_id = 42857
self.__get_mol_file(read_id, retrieved_id)
def test_get_names_existing(self):
'''COMMENT'''
this_name = Name('Grape sugar', 'SYNONYM', 'KEGG COMPOUND', False,
'en')
self.assertTrue(this_name in self.__existing.get_names())
def test_get_names_secondary(self):
'''COMMENT'''
this_name = Name('eau', 'SYNONYM', 'ChEBI', False, 'fr')
self.assertTrue(this_name in self.__secondary.get_names())
def test_get_references_existing(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('15347')
this_reference = Reference('WO2006008754', 'Patent', '',
'NOVEL INTERMEDIATES FOR LINEZOLID '
'AND RELATED COMPOUNDS')
self.assertTrue(this_reference in this_chebi_entity.get_references())
def test_get_references_secondary(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('22182')
this_reference = Reference('WO2006008754', 'Patent', '',
'NOVEL INTERMEDIATES FOR LINEZOLID '
'AND RELATED COMPOUNDS')
self.assertTrue(this_reference in this_chebi_entity.get_references())
def test_get_cmp_orig_existing(self):
'''COMMENT'''
this_compound_origin = CompoundOrigin('H**o sapiens', 'NCBI:9606',
None, None, None, None,
'DOI', '10.1038/nbt.2488', None)
self.assertTrue(this_compound_origin
in self.__existing.get_compound_origins())
def test_get_cmp_orig_secondary(self):
'''COMMENT'''
this_compound_origin = CompoundOrigin('H**o sapiens', 'NCBI:9606',
None, None, None, None,
'DOI', '10.1038/nbt.2488', None)
self.assertTrue(this_compound_origin
in self.__secondary.get_compound_origins())
def test_get_out_existing(self):
'''COMMENT'''
this_relation = Relation('is_a', '17634', 'C')
self.assertTrue(this_relation in self.__existing.get_outgoings())
def test_get_out_secondary(self):
'''COMMENT'''
this_relation = Relation('has_role', 'CHEBI:48360', 'C')
self.assertTrue(this_relation in self.__secondary.get_outgoings())
def test_get_in_existing(self):
'''COMMENT'''
this_relation = Relation('has_functional_parent', 'CHEBI:15866', 'C')
self.assertTrue(this_relation in self.__existing.get_incomings())
def test_get_in_secondary(self):
'''COMMENT'''
this_relation = Relation('is_conjugate_acid_of', '29412', 'C')
self.assertTrue(this_relation in self.__secondary.get_incomings())
def __get_mol_file(self, read_id, retrieved_id):
'''COMMENT'''
mol_read = _read_mol_file(read_id)
this_chebi_entity = ChebiEntity(str(retrieved_id))
textfile_retrieved = open(this_chebi_entity.get_mol_filename(), 'r')
mol_retrieved = textfile_retrieved.read()
textfile_retrieved.close()
self.assertEquals(mol_read, mol_retrieved)
def get_cmpd_information(molec):
"""Get information from CHEBI Database of a compound from CHEBI ID.
Online using libChEBIpy (https://github.com/libChEBI/libChEBIpy)
"""
if molec.chebiID is None and molec.iupac_name is not None:
# try one more time for chebi ID
chebiID = get_chebiID(mol_name=molec.name, iupac_name=molec.iupac_name)
if chebiID is None:
print('cannot get structure from chebi')
return None
molec.chebiID = [chebiID]
# at this point, molec.chebiID will be a list - iterarte over it
# the iteration stops if any CHEBI ID produces a structure
for CID in molec.chebiID:
if CID == '' or ' ' in CID or 'null' in CID:
print(CID, '- not a real CHEBI ID')
continue
# get entity with chebiID
entity = ChebiEntity(CID)
# check for parent ID
entity, CID = convert_entity_to_parent(entity, ID=CID, CID=CID)
# attemp to get structure
# SMILES
smile = entity.get_smiles()
print('libchebipy result:', smile)
if smile is not None:
rdkitmol = Chem.MolFromSmiles(smile)
if rdkitmol is None:
print('structure could not be deciphered')
molec.SMILES = smile
molec.mol = None
continue
else:
rdkitmol.Compute2DCoords()
molec.SMILES = smile
# remove molecules with generalised atoms
if '*' in smile:
molec.mol = None
else:
molec.mol = rdkitmol
elif smile is None:
print('molecule does not have recorded structure in CHEBI DB')
print('probably a generic structure - skipping.')
molec.SMILES = smile
molec.mol = None
continue
# set passed = True if this chebi ID produced a structure
# would not get up to this point if it didnt
# if not CIDs pass then the chebiIDs remain a list and will
# fail the
# next step
passed = True
# set molecule properties
if passed:
molec.chebiID = CID
molec.DB_ID = CID
# save InChiKey
iKEY = entity.get_inchi_key()
if iKEY is not None:
molec.InChiKey = iKEY
# save inchi
inchi = entity.get_inchi()
if inchi is not None:
molec.InChi = inchi
# set name if name is only a code at this point
try:
if molec.change_name is True:
molec.name = entity.get_name()
molec.change_name = False
except AttributeError:
molec.change_name = False
return None
def data(request, domain, id):
file_header = ''
if domain == 'papers':
paper = get_object_or_404(Paper, pk=id)
datasets = paper.dataset_set
file_header = u'# Paper: %s (PMID %s)\n' % (paper, paper.pmid)
if domain == 'datasets':
# datasets = get_object_or_404(Dataset, pk=id)
datasets = Dataset.objects.filter(pk=id)
dataset = datasets.first()
file_header = u'# Paper: %s (PMID %s)\n# Dataset: %s\n' % (
dataset.paper, dataset.paper.pmid, dataset)
if domain == 'conditions':
conditiontype = get_object_or_404(ConditionType, pk=id)
datasets = conditiontype.datasets()
file_header = u'# Condition: %s (ID %s)\n' % (conditiontype,
conditiontype.id)
if domain == 'chebi':
chebi_entity = ChebiEntity('CHEBI:' + str(id))
children = []
for relation in chebi_entity.get_incomings():
if relation.get_type() == 'has_role':
tid = relation.get_target_chebi_id()
tid = int(filter(str.isdigit, tid))
children.append(tid)
datasets = Dataset.objects.filter(
conditionset__conditions__type__chebi_id__in=children)
file_header = u'# Data for conditions annotated as %s (ChEBI:%s)\n' % (
chebi_entity.get_name(), id)
if domain == 'phenotypes':
phenotype = get_object_or_404(Observable, pk=id)
datasets = phenotype.datasets()
file_header = u'# Phenotype: %s (ID %s)\n' % (phenotype, phenotype.id)
data = Data.objects.filter(dataset_id__in=datasets.values('id')).all()
orfs = list(data.values_list('orf', flat=True).distinct())
datasets_ids = list(
data.values_list('dataset_id',
flat=True).order_by('dataset__paper').distinct())
matrix = [[None] * len(datasets_ids) for i in orfs]
for datapoint in data:
i = orfs.index(datapoint.orf)
j = datasets_ids.index(datapoint.dataset_id)
matrix[i][j] = datapoint.value
column_headers = '\t' + '\t'.join([
u'%s' % get_object_or_404(Dataset, pk=dataset_id)
for dataset_id in datasets_ids
]) + '\n'
data_row = []
for i, orf in enumerate(orfs):
new_row = orf + '\t' + '\t'.join([str(val) for val in matrix[i]])
print(new_row)
data_row.append(new_row)
txt3 = '\n'.join(data_row)
response = HttpResponse(file_header + column_headers + txt3,
content_type='text/plain')
response[
'Content-Disposition'] = 'attachment; filename="%s_%s_%s_data.txt"' % (
settings.DOWNLOAD_PREFIX, domain, id)
return response
class TestChebiEntity(unittest.TestCase):
'''COMMENT'''
def setUp(self):
'''COMMENT'''
self.__existing = ChebiEntity('4167')
self.__secondary = ChebiEntity('CHEBI:5585')
def test_get_non_existing(self):
'''COMMENT'''
self.assertRaises(ChebiException, ChebiEntity, '-1')
def test_get_id_existing(self):
'''COMMENT'''
self.assertTrue(self.__existing.get_id() == 'CHEBI:4167')
def test_get_id_secondary(self):
'''COMMENT'''
self.assertTrue(self.__secondary.get_id() == 'CHEBI:5585')
def test_get_formulae_existing(self):
'''COMMENT'''
this_formula = Formula('C6H12O6', 'KEGG COMPOUND')
self.assertTrue(this_formula in self.__existing.get_formulae())
def test_get_formulae_secondary(self):
'''COMMENT'''
this_formula = Formula('H2O', 'ChEBI')
self.assertTrue(this_formula in self.__secondary.get_formulae())
def test_get_formula_existing(self):
'''COMMENT'''
self.assertTrue(self.__existing.get_formula() == 'C6H12O6')
def test_get_formula_secondary(self):
'''COMMENT'''
self.assertTrue(self.__secondary.get_formula() == 'H2O')
def test_get_mass_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_mass(), 180.15588)
def test_get_mass_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_mass(), 18.01530)
def test_get_charge_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_charge(), 0)
def test_get_charge_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_charge(), 0)
def test_get_charge_secondary2(self):
'''COMMENT'''
self.assertEquals(-2, ChebiEntity('43474').get_charge())
def test_get_comments_existing(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('29044')
this_comment = Comment(
'General', 'General',
'The substituent name \'3-oxoprop-2-enyl\' is '
'incorrect but is used in various databases.',
datetime.datetime.strptime('2005-03-18', '%Y-%M-%d'))
self.assertTrue(this_comment in this_chebi_entity.get_comments())
def test_get_comments_secondary(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('11505')
this_comment = Comment(
'General', 'General',
'The substituent name \'3-oxoprop-2-enyl\' is '
'incorrect but is used in various databases.',
datetime.datetime.strptime('2005-03-18', '%Y-%M-%d'))
self.assertTrue(this_comment in this_chebi_entity.get_comments())
def test_get_source_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_source(), 'KEGG COMPOUND')
def test_get_source_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_source(), 'KEGG COMPOUND')
def test_get_prnt_id_existing(self):
'''COMMENT'''
self.assertIsNone(self.__existing.get_parent_id())
def test_get_prnt_id_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_parent_id(), 'CHEBI:15377')
def test_get_name_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_name(), 'D-glucopyranose')
def test_get_name_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_name(), 'water')
def test_get_definition_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_definition(),
'A glucopyranose having D-configuration.')
def test_get_definition_secondary(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('41140')
self.assertEqual(
this_chebi_entity.get_definition(),
'D-Glucopyranose with beta configuration at the '
'anomeric centre.')
def test_get_mod_on_existing(self):
'''COMMENT'''
self.assertTrue(self.__existing.get_modified_on() >
datetime.datetime.strptime('2014-01-01', '%Y-%M-%d'))
def test_get_mod_on_secondary(self):
'''COMMENT'''
self.assertIsNotNone(self.__secondary.get_modified_on())
def test_get_created_by_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_created_by(), 'CHEBI')
def test_get_created_by_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_created_by(), 'ops$mennis')
def test_get_star_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_star(), 3)
def test_get_star_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_star(), 3)
def test_get_db_acc_existing(self):
'''COMMENT'''
dat_acc = DatabaseAccession('MetaCyc accession', 'D-Glucose',
'MetaCyc')
self.assertTrue(dat_acc in self.__existing.get_database_accessions())
def test_get_db_acc_secondary(self):
'''COMMENT'''
dat_acc = DatabaseAccession('MetaCyc accession', 'WATER', 'MetaCyc')
self.assertTrue(dat_acc in self.__secondary.get_database_accessions())
def test_get_inchi_existing(self):
'''COMMENT'''
inchi = 'InChI=1S/C6H12O6/c7-1-2-3(8)4(9)5(10)6(11)12-2/' + \
'h2-11H,1H2/t2-,3-,4+,5-,6?/m1/s1'
self.assertEqual(self.__existing.get_inchi(), inchi)
def test_get_inchi_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_inchi(), 'InChI=1S/H2O/h1H2')
def test_get_inchi_key_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_inchi_key(),
'WQZGKKKJIJFFOK-GASJEMHNSA-N')
def test_get_inchi_key_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_inchi_key(),
'XLYOFNOQVPJJNP-UHFFFAOYSA-N')
def test_get_smiles_existing(self):
'''COMMENT'''
self.assertEqual(self.__existing.get_smiles(),
'OC[C@H]1OC(O)[C@H](O)[C@@H](O)[C@@H]1O')
def test_get_smiles_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_smiles(), '[H]O[H]')
def test_get_mol_existing(self):
'''COMMENT'''
chebi_id = 73938
this_chebi_entity = ChebiEntity(str(chebi_id))
self.assertEqual(this_chebi_entity.get_mol(), _read_mol_file(chebi_id))
def test_get_mol_secondary(self):
'''COMMENT'''
self.assertEqual(self.__secondary.get_mol(), _read_mol_file(15377))
def test_get_mol_file_existing(self):
'''COMMENT'''
chebi_id = 73938
self.__get_mol_file(chebi_id, chebi_id)
def test_get_mol_file_secondary(self):
'''COMMENT'''
read_id = 15377
retrieved_id = 42857
self.__get_mol_file(read_id, retrieved_id)
def test_get_names_existing(self):
'''COMMENT'''
this_name = Name('Grape sugar', 'SYNONYM', 'KEGG COMPOUND', False,
'en')
self.assertTrue(this_name in self.__existing.get_names())
def test_get_names_secondary(self):
'''COMMENT'''
this_name = Name('eau', 'SYNONYM', 'ChEBI', False, 'fr')
self.assertTrue(this_name in self.__secondary.get_names())
def test_get_references_existing(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('15347')
this_reference = Reference(
'WO2006008754', 'Patent', '', 'NOVEL INTERMEDIATES FOR LINEZOLID '
'AND RELATED COMPOUNDS')
self.assertTrue(this_reference in this_chebi_entity.get_references())
def test_get_references_secondary(self):
'''COMMENT'''
this_chebi_entity = ChebiEntity('22182')
this_reference = Reference(
'WO2006008754', 'Patent', '', 'NOVEL INTERMEDIATES FOR LINEZOLID '
'AND RELATED COMPOUNDS')
self.assertTrue(this_reference in this_chebi_entity.get_references())
def test_get_cmp_orig_existing(self):
'''COMMENT'''
this_compound_origin = CompoundOrigin('H**o sapiens', 'NCBI:9606',
None, None, None, None, 'DOI',
'10.1038/nbt.2488', None)
self.assertTrue(
this_compound_origin in self.__existing.get_compound_origins())
def test_get_cmp_orig_secondary(self):
'''COMMENT'''
this_compound_origin = CompoundOrigin('H**o sapiens', 'NCBI:9606',
None, None, None, None, 'DOI',
'10.1038/nbt.2488', None)
self.assertTrue(
this_compound_origin in self.__secondary.get_compound_origins())
def test_get_out_existing(self):
'''COMMENT'''
this_relation = Relation('is_a', '17634', 'C')
self.assertTrue(this_relation in self.__existing.get_outgoings())
def test_get_out_secondary(self):
'''COMMENT'''
this_relation = Relation('has_role', 'CHEBI:48360', 'C')
self.assertTrue(this_relation in self.__secondary.get_outgoings())
def test_get_in_existing(self):
'''COMMENT'''
this_relation = Relation('has_functional_parent', 'CHEBI:15866', 'C')
self.assertTrue(this_relation in self.__existing.get_incomings())
def test_get_in_secondary(self):
'''COMMENT'''
this_relation = Relation('is_conjugate_acid_of', '29412', 'C')
self.assertTrue(this_relation in self.__secondary.get_incomings())
def __get_mol_file(self, read_id, retrieved_id):
'''COMMENT'''
mol_read = _read_mol_file(read_id)
this_chebi_entity = ChebiEntity(str(retrieved_id))
textfile_retrieved = open(this_chebi_entity.get_mol_filename(), 'r')
mol_retrieved = textfile_retrieved.read()
textfile_retrieved.close()
self.assertEquals(mol_read, mol_retrieved)