def test_mass_delta(self):
     r = self.create_reacts([('methylation', '[N,O:1]>>[*:1]-[#6]')
                             ])['methylation']
     m = Molecule.load_from_smiles('CCO')
     self.assertIsNone(r.mass_delta())
     r.run_reaction([m])
     self.assertEqual(round(r.mass_delta(), 6), 14.01565)
    def test_fs_gen_mgf(self):
        smiles = FragCommonTests.test_data['smiles']
        m = Molecule.load_from_smiles(smiles)
        fs = FragCommonTests.new_frag_sim()
        fm = fs.frag_molecule(m, adduct='M+')
        #'PEPMASS=45.0447245801'
        #'MOLECULAR_FORMULA=CH5N2+'
        exp_res = '\n'.join([\
                        'BEGIN IONS',\
                        'PEPMASS=45.0447245801',\
                        'CHARGE=1+',\
                        'FILENAME=METWORK_' + str(m.id), \
                        'SMILES=N=C[NH3+]',\
                        'INCHI=InChI=1S/CH4N2/c2-1-3/h1H,(H3,2,3)/p+1',\
                        'INCHIAUX=PNKUSGQVOMIXLU-UHFFFAOYSA-O',\
                        'SCANS=' + str(m.id), \
                        #'18.033826 0.397148', 
                        #'28.018175 0.993644', 
                        #'45.044725 98.609208',



                        '18.0338255500 0.3971478062',
                        '28.0181754800 0.9936442241',
                        '45.0447245800 98.6092079700',
                        'END IONS',
                        ]) + u'\n'
        self.assertEqual(fm.gen_mgf(energy=0, decimal=10), exp_res)
Exemple #3
0
 def load_smiles(self, request, pk=None):
     data = JSONParser().parse(request)
     mols = Molecule.load_from_smiles(data["smiles"].replace("\n", "."))
     if mols != False:
         return JsonResponse({"success": [mols.chemdoodle_json]})
     else:
         return JsonResponse({"error": "unable to load smiles"})
 def load_smiles(self, request, pk=None):
     data = JSONParser().parse(request)
     mols = Molecule.load_from_smiles(data['smiles'].replace('\n', '.'))
     if mols != False:
         return JsonResponse({'success': [mols.chemdoodle_json]})
     else:
         return JsonResponse({'error': 'unable to load smiles'})
Exemple #5
0
 def test_frag_mol(self):
     fs = FragCommonTests.new_frag_sim()
     smiles = FragCommonTests.test_data['smiles']
     m = Molecule.load_from_smiles(smiles)
     self.assertFalse(fs.get_frag_mol(m))
     fs.frag_molecule(m)
     self.assertTrue(fs.get_frag_mol(m))
Exemple #6
0
 def test_mass_delta(self):
     r = self.create_reacts([("methylation", "[N,O:1]>>[*:1]-[#6]")
                             ])["methylation"]
     m = Molecule.load_from_smiles("CCO")
     self.assertIsNone(r.mass_delta())
     r.run_reaction([m])
     self.assertEqual(round(r.mass_delta(), 6), 14.01565)
Exemple #7
0
 def test_fs_gen_mgf(self):
     smiles = FragCommonTests.test_data["smiles"]
     m = Molecule.load_from_smiles(smiles)
     fs = FragCommonTests.new_frag_sim()
     fm = fs.frag_molecule(m, adduct="M+")
     #'PEPMASS=45.0447245801'
     #'MOLECULAR_FORMULA=CH5N2+'
     exp_res = (
         "\n".join([
             "BEGIN IONS",
             "PEPMASS=45.0447245801",
             "CHARGE=1+",
             "FILENAME=METWORK_" + str(m.id),
             "SMILES=N=C[NH3+]",
             "INCHI=InChI=1S/CH4N2/c2-1-3/h1H,(H3,2,3)/p+1",
             "INCHIAUX=PNKUSGQVOMIXLU-UHFFFAOYSA-O",
             "SCANS=" + str(m.id),  #'18.033826 0.397148',
             #'28.018175 0.993644',
             #'45.044725 98.609208',
             "18.0338255500 0.3971478062",
             "28.0181754800 0.9936442241",
             "45.0447245800 98.6092079700",
             "END IONS",
         ]) + "\n")
     self.assertEqual(fm.gen_mgf(energy=0, decimal=10), exp_res)
 def test_reset_react_process(self):
     # reset react process if not ACTIVE
     r = self.create_reacts([('methylation', '[N,O:1]>>[*:1]-[#6]-[#6]')
                             ])['methylation']
     co = Molecule.load_from_smiles('CO')
     cco = Molecule.load_from_smiles('CCO')
     self.assertEqual(r.reactprocess_set.count(), 0)
     r.run_reaction([cco])
     self.assertEqual(r.reactprocess_set.count(), 1)
     r.smarts = '[N,O:1]>>[*:1]-[#6]'
     r.save()
     r.run_reaction([co])
     self.assertEqual(r.reactprocess_set.count(), 1)
     r.status_code = Reaction.status.ACTIVE
     r.save()
     r.run_reaction([cco])
     self.assertEqual(r.reactprocess_set.count(), 2)
Exemple #9
0
 def test_reset_react_process(self):
     # reset react process if not ACTIVE
     r = self.create_reacts([("methylation", "[N,O:1]>>[*:1]-[#6]-[#6]")],
                            activate=False)["methylation"]
     co = Molecule.load_from_smiles("CO")
     cco = Molecule.load_from_smiles("CCO")
     self.assertEqual(r.reactprocess_set.count(), 0)
     r.run_reaction([cco])
     self.assertEqual(r.reactprocess_set.count(), 1)
     r.smarts = "[N,O:1]>>[*:1]-[#6]"
     r.save()
     r.run_reaction([co])
     self.assertEqual(r.reactprocess_set.count(), 1)
     r.status_code = Reaction.status.ACTIVE
     r.save()
     r.run_reaction([cco])
     self.assertEqual(r.reactprocess_set.count(), 2)
Exemple #10
0
    def json_to_mol(self, json_data):
        from base.models import Molecule

        mol_rdkit = self.json_to_rdkit(json_data)
        smiles = Chem.MolToSmiles(mol_rdkit)
        smiles = RDKit.mol_to_smiles(mol_rdkit)
        # return Molecule.load_from_rdkit(mol_rdkit)
        return Molecule.load_from_smiles(Chem.MolToSmiles(mol_rdkit))
Exemple #11
0
 def test_frag_mol(self):
     fs = FragCommonTests.new_frag_sim()
     smiles = FragCommonTests.test_data["smiles"]
     m = Molecule.load_from_smiles(smiles)
     adduct = "M+"
     self.assertFalse(fs.get_frag_mol(m, adduct=adduct))
     fs.frag_molecule(m, adduct=adduct)
     self.assertTrue(fs.get_frag_mol(m, adduct=adduct))
 def add_annotation(self, ion_id, smiles, db_source='', db_id=''):
     # ===> Add ion_name !
     from fragmentation.models import FragAnnotationDB
     fms = self.fragmolsample_set.get(ion_id=int(ion_id))
     return FragAnnotationDB.objects.create(
         frag_mol_sample=fms,
         molecule=Molecule.load_from_smiles(smiles),
         db_source=db_source,
         db_id=db_id)
 def test_mol_to_json(self):
     smiles = 'C/C(F)=C/[C@@](C)(N)c1ccc(O)cc1'
     mol = Molecule.load_from_smiles(smiles)
     json_path = 'base/tests/files/chemdoodle_mol_1.json'
     cd = ChemDoodle()
     with open(json_path, 'r') as fjson:
         json_str = '[{0}]'.format(fjson.readline())
         json_mol = json.loads(json_str)[0]['m'][0]
     json_res = cd.mol_to_json(mol)
     self.assertEqual(cd.json_to_mol(json_res).smiles(), smiles)
    def test_get_adduct(self):

        PARENT_MASS = 382.32800
        SMILES = 'OCC(OC/C=C(C)/CC/C=C(C)/CC/C=C(C)/CC/C=C(C)/C)CO'
        ION_CHARGE = 'positive'
        ADDUCT_TARGET = 'M+NH4'

        fms = FragMolSample(parent_mass=PARENT_MASS)
        m = Molecule.load_from_smiles(SMILES)
        ad = AdductManager(ION_CHARGE)
        self.assertEqual(ad.get_adduct(m, fms), ADDUCT_TARGET)
    def import_annotation_file(self, file_object, file_format="default"):
        from fragmentation.models import FragMolSample, FragAnnotationDB

        delimiter_by_format = {"GNPS": "\t"}
        quotechar_by_format = {"GNPS": None}
        data = [row.decode() for row in file_object.readlines()]
        data = list(
            csv.reader(
                data,
                delimiter=delimiter_by_format.get(file_format, ","),
                quotechar=quotechar_by_format.get(file_format, '"'),
            ))
        errors = {}
        col_titles = data[0]
        for idx, line in enumerate(data[1:]):
            try:
                status_id = AnnotationStatus.VALIDATED
                if file_format == "default":
                    ion_id, name, smiles, db_source, db_id = line
                if file_format == "level":
                    ion_id, name, smiles, db_source, db_id, level = line
                    status_id = STATUS_LEVEL_MAPPING.get(
                        int(level), AnnotationStatus.UNRATED)
                elif file_format == "GNPS":
                    ion_id = line[col_titles.index("#Scan#")]
                    name = line[col_titles.index("Compound_Name")]
                    smiles = line[col_titles.index("Smiles")]

                    db_source = "GNPS : {0}, {1}".format(
                        line[col_titles.index("Compound_Source")],
                        line[col_titles.index("Data_Collector")],
                    )
                    db_id = line[col_titles.index("CAS_Number")]

                if int(ion_id) > 0:

                    molecule = Molecule.load_from_smiles(smiles)
                    fms = self.fragmolsample_set.get(ion_id=ion_id)
                    self.add_annotation(
                        frag_mol_sample=fms,
                        molecule=molecule,
                        name=name,
                        db_source=db_source,
                        db_id=db_id,
                        status_id=status_id,
                    )

            except Exception as err:
                # print(err)
                errors[idx] = {"err": str(err), "idx": idx}
        return {
            "success": "Annotations successfully imported",
            "errors": errors
        }
Exemple #16
0
 def test_frag_mol_neg(self):
     fsc = FragSimConf.objects.create(
         param_path="param/param_output0_neg.log",
         conf_path="conf/param_config_neg.txt",
     )
     fs = FragSim(fsc)
     smiles = "CCC(C)O"
     m = Molecule.load_from_smiles(smiles)
     adduct = "M-"
     assert not fs.get_frag_mol(m, adduct=adduct)
     fs.frag_molecule(m, adduct=adduct, ion_charge="negative")
     fms = fs.get_frag_mol(m, adduct=adduct)
     assert fms
     spectrum = fms.fragmolspectrum_set.filter(energy=0).first().spectrum
     assert spectrum[0][0] == 17.00328823
    def import_annotation_file(self, file_object, file_format='default'):
        from fragmentation.models import FragMolSample, FragAnnotationDB
        am = AdductManager(ion_charge=self.ion_charge)
        fls = [l.decode('utf-8') for l in file_object.readlines()]
        errors = {}
        col_titles = fls[0].split("\t")
        for i, fl in enumerate(fls[1:]):
            try:
                if file_format == 'default':
                    ion_id, name, smiles, db_source, db_id = fl.split(
                        "\n")[0].split(",")
                elif file_format == 'GNPS':
                    data = fl.split("\t")
                    ion_id = data[col_titles.index('#Scan#')]
                    name = data[col_titles.index('Compound_Name')]
                    smiles = data[col_titles.index('Smiles')]

                    db_source = 'GNPS : {0}, {1}'.format(
                        data[col_titles.index('Compound_Source')],
                        data[col_titles.index('Data_Collector')])
                    db_id = data[col_titles.index('CAS_Number')]

                if int(ion_id) > 0:
                    m = Molecule.load_from_smiles(smiles)
                    fms = self.fragmolsample_set.get(ion_id=ion_id)

                    adduct = am.get_adduct(m, fms)

                    if adduct is not None:
                        if fms.adduct is None:
                            fms.adduct = adduct
                            fms.save()

                        if fms.adduct == adduct:
                            fa = FragAnnotationDB.objects.create(
                                frag_mol_sample=fms,
                                molecule=m,
                                name=name,
                                db_source=db_source,
                                db_id=db_id)

            except Exception as err:
                # print(err)
                errors[i] = {'err': str(err), 'smiles': smiles}
        return {
            'success': 'Annotations successfully imported',
            'errors': errors
        }
    def test_cosine_mgf_sim(self):
        # user = get_user_model().objects.create()
        fc = self.new_frag_compare()
        with open(self.TEST_FILES_PATH + "cosine_4.mgf", "rb") as fr:
            fsample = FragSample.import_sample(
                fr, FragCompareModelTests.user, "name", "file_name"
            )
            fsample.wait_import_done()

        sm = "N=C(N)NCC/C=C1/N=C(O)N(/C=C/c2ccc(O)cc2)C1=O"
        m = Molecule.load_from_smiles(sm)
        fsim = FragCommonTests.new_frag_sim()
        fms = fsim.frag_molecule(m)
        fmc = fc.compare_frag_mols([fsample.fragmolsample_set.first(), fms])
        # print(fmc.cosine)#, fmc.num_frag_match
        self.assertTrue(fmc.cosine >= 0.2, fmc.cosine)
Exemple #19
0
 def test_process_reaction_double_reactants(self):
     r = self.create_reacts([("diels_alder", None)])["diels_alder"]
     smiles = ["C=Cc1c[nH]c(N)n1", "C=CCC"]
     expected_smiles = ["CCC1CCC=C2N=C(N)NC12", "CCC1CC=C2N=C(N)NC2C1"]
     ml = [Molecule.load_from_smiles(sm) for sm in smiles]
     smarts = "[#6:1]=,:[#6:2]-[#6:3]=,:[#6:4].[#6:5]=,:[#6:6]>>[#6:1]1-[#6:2]=,:[#6:3]-[#6:4]-[#6:6]-[#6:5]-1"
     r.load_smarts(smarts)
     for i in range(2):
         rp = ReactProcess.objects.create(reaction=r)
         for m in ml:
             rp.reactants.add(m)
         rp.save()
         rp.run_reaction()
         # Check if molecule has been created
         expected_mols = {
             Molecule.find_from_smiles(sm)
             for sm in expected_smiles
         }
         self.assertEqual(set(rp.products.all()), expected_mols)
         ml.reverse()
    def add_annotation_from_smiles(
        self,
        ion_id,
        smiles,
        name="",
        db_source="",
        db_id="",
        status_id=AnnotationStatus.UNDEFINED,
    ):

        molecule = Molecule.load_from_smiles(smiles)
        fms = self.fragmolsample_set.get(ion_id=int(ion_id))

        self.add_annotation(
            frag_mol_sample=fms,
            molecule=molecule,
            name=name,
            db_source=db_source,
            db_id=db_id,
            status_id=status_id,
        )
Exemple #21
0
 def test_process_reaction_single_reactant(self):
     r = self.create_reacts([("methylation", "[N,O:1]>>[*:1]-[#6]")
                             ])["methylation"]
     sm = "NC=C(N)C"
     expected_smiles = ["CNC=C(C)N", "CNC(C)=CN"]
     m = Molecule.load_from_smiles(sm)
     m.save()
     # Reaction.reactions_update()
     r = Reaction.objects.get(name="methylation")
     rp = ReactProcess.objects.create(reaction=r)
     rp.reactants.add(m)
     rp.run_reaction()
     # Check if molecule has been created
     expected_mols = {
         Molecule.find_from_smiles(sm)
         for sm in expected_smiles
     }
     self.assertTrue(not False in expected_mols)
     # Check if reaction_product has been created
     self.assertEqual(rp.products.count(), 2)
     for m_exp in expected_mols:
         self.assertTrue(m_exp in rp.products.all())
 def run_reaction(self, request, pk=None):
     data = JSONParser().parse(request)
     chemdoodle_json = data['reactants']['chemdoodle_json']
     if 'm' in chemdoodle_json:
         cd = ChemDoodle()
         reactants = [
             cd.json_to_mol(mol_json) for mol_json in chemdoodle_json['m']
         ]
         reactants_smiles = reactants[0].smiles()
         if '.' in reactants_smiles:
             reactants = [
                 Molecule.load_from_smiles(sm) \
                 for sm in reactants_smiles.split('.')]
         r = self.get_object()
         rp = r.run_reaction(reactants)
         response = {
             'reactants': [r.chemdoodle_json for r in rp.reactants.all()],
             'products': [p.chemdoodle_json for p in rp.products.all()]
         }
         return JsonResponse(response)
     else:
         return JsonResponse({'error': 'test'})
Exemple #23
0
 def run_reaction(self, request, pk=None):
     data = JSONParser().parse(request)
     chemdoodle_json = data["reactants"]["chemdoodle_json"]
     if "m" in chemdoodle_json:
         cd = ChemDoodle()
         reactants = [
             cd.json_to_mol(mol_json) for mol_json in chemdoodle_json["m"]
         ]
         reactants_smiles = reactants[0].smiles()
         if "." in reactants_smiles:
             reactants = [
                 Molecule.load_from_smiles(sm)
                 for sm in reactants_smiles.split(".")
             ]
         r = self.get_object()
         rp = r.run_reaction(reactants)
         response = {
             "reactants": [r.chemdoodle_json for r in rp.reactants.all()],
             "products": [p.chemdoodle_json for p in rp.products.all()],
         }
         return JsonResponse(response)
     else:
         return JsonResponse({"error": "test"})
Exemple #24
0
 def test_load_from_smiles(self):
     m = Molecule.create_from_smiles('CCC')
     self.assertIsNot(Molecule.load_from_smiles('CCC'), False)
     self.assertIsNot(Molecule.load_from_smiles('CCCC'), False)
     self.assertFalse(Molecule.load_from_smiles('HHOHH'))
    def test_mass_selection(self):
        u = get_user_model().objects.create(email='*****@*****.**')
        methylation = Reaction.objects.create(user=u,
                                              name='methylation',
                                              smarts='[N,O:1]>>[*:1]-[#6]')
        methylation.run_reaction([Molecule.load_from_smiles('CCO')])
        methylation_modified = Reaction.objects.create(
            user=u, name='methylation_modified', smarts='[N,O:1]>>IC(I)C[*:1]')
        methylation_modified.run_reaction([Molecule.load_from_smiles('CCO')])
        diels_alder = Reaction.objects.create(
            user=u,
            name='diels_alder',
            smarts=
            '[#6:1]=,:[#6:2]-[#6:3]=,:[#6:4].[#6:5]=,:[#6:6]>>[#6:1]1-[#6:2]=,:[#6:3]-[#6:4]-[#6:6]-[#6:5]-1'
        )
        diels_alder.run_reaction([
            Molecule.load_from_smiles('C=Cc1c[nH]c(N)n1'),
            Molecule.load_from_smiles('C=C')
        ])
        diels_alder_modified = Reaction.objects.create(
            user=u,
            name='diels_alder_modified',
            smarts=
            '[#6:1]=,:[#6:2]-[#6:3]=,:[#6:4]-[H].[#6:5]=,:[#6:6]>>[#6]-[#6:2]-1=,:[#6:3]-[#6:4]-[#6:6]-[#6:5]-[#6:1]-1'
        )
        diels_alder_modified.run_reaction([
            Molecule.load_from_smiles('C=Cc1c[nH]c(N)n1'),
            Molecule.load_from_smiles('C=C')
        ])
        for r in [methylation, diels_alder, diels_alder_modified]:
            r.status_code = Reaction.status.ACTIVE
            r.save()

        sample_folder = 'fragmentation/tests/files/test_annotation_project/'
        sample_file_path = sample_folder + 'test_annotation_project.mgf'
        anno_file_path = sample_folder + 'anno_1.csv'

        with open(sample_file_path, 'rb') as fss:
            fs = FragSample.import_sample(fss, u, energy=2)

        # Import annotation
        with open(anno_file_path, 'rb') as f_annot:
            fs.import_annotation_file(f_annot)

        p = SampleAnnotationProject.objects.create(\
            user = u,
            depth_total = 3,
            depth_last_match = 0)
        p.save()
        p.update_frag_sample(fs)
        p.select_reactions_by_mass()

        self.assertIn(methylation, p.reactions())
        self.assertNotIn(methylation_modified, p.reactions())
        self.assertIn(diels_alder, p.reactions())
        self.assertNotIn(diels_alder_modified, p.reactions())

        # test frag_sample.gen_mass_delta reevaluation
        # when new reaction added
        methylation_modified.status_code = Reaction.status.ACTIVE
        methylation_modified.save()
        self.assertNotIn(methylation_modified, p.reactions())
        p.select_reactions_by_mass()
        self.assertIn(methylation_modified, p.reactions())
 def new_frag_mol_sim(self, smiles='N=C([NH3+])', adduct='M+'):
     fs = FragCommonTests.new_frag_sim()
     m = Molecule.load_from_smiles(smiles)
     return fs.create_frag_mol_sim(molecule=m, adduct=adduct), fs
Exemple #27
0
 def test_load_from_smiles(self):
     m = Molecule.create_from_smiles("CCC")
     self.assertIsNot(Molecule.load_from_smiles("CCC"), False)
     self.assertIsNot(Molecule.load_from_smiles("CCCC"), False)
     self.assertFalse(Molecule.load_from_smiles("HHOHH"))