def test2(): smiles, id = "OC1=C(Cl)C=CC=C1[N+]", 1 mol = Smiles.smilin(smiles) print mol.cansmiles() for atom in mol.atoms: print atom.index
def cansmiles(self) : """ affiche en canonical smiles une brique """ # sys.stderr.write("Brique.cansmiles: will call molecule.cansmiles() ...\n") a = self.molecule.cansmiles() m = Smiles.smilin("".join(re.split("[\[\]+-]","".join(re.split("H[0-9]*",a))))) return m.cansmiles()
def test(): from frowns import Smiles import time smiles, id = "OC1=C(Cl)C=CC=C1[N+]C2CCC3CC3CCC2", 1 mol = Smiles.smilin(smiles, transforms=[]) t1 = time.time() for i in range(100): atoms, bonds = getAtomsBondsInRings(mol) print(time.time() - t1) / 100
def test(): from frowns import Smiles import time smiles, id = "OC1=C(Cl)C=CC=C1[N+]C2CCC3CC3CCC2", 1 mol = Smiles.smilin(smiles, transforms=[]) t1 = time.time() for i in range(100): atoms, bonds = getAtomsBondsInRings(mol) print (time.time() - t1)/100
def checkSmiles(fname): from frowns import Smiles try: fSmiles = open(fname, "r") lines = fSmiles.readlines() fSmiles.close() asmiles = Smiles.smilin(lines[0].split()[0]) return True except: return False
def test(): from frowns import Smiles import time smiles, id = "OC1=C(Cl)C=CC=C1[N+]C2CCC3CC3CCC2", 1 mol = Smiles.smilin(smiles, transforms=[]) assert frerejaqueNumber(mol) == 3 t1 = time.time() for i in range(100): frerejaqueNumber(mol) print(time.time() - t1) / 100
def test(): from frowns import Smiles import time smiles, id = "OC1=C(Cl)C=CC=C1[N+]C2CCC3CC3CCC2", 1 mol = Smiles.smilin(smiles, transforms=[]) assert frerejaqueNumber(mol) == 3 t1 = time.time() for i in range(100): frerejaqueNumber(mol) print (time.time() - t1)/100
def cansmiles(self): """ affiche en canonical smiles une brique """ # sys.stderr.write("Brique.cansmiles: will call molecule.cansmiles() ...\n") a = self.molecule.cansmiles() m = Smiles.smilin("".join( re.split("[\[\]+-]", "".join(re.split("H[0-9]*", a))))) return m.cansmiles()
def next(self): if not self.smiles: return None smile = self.smiles.pop() m = Smiles.smilin(smile) #addCoords(m) #toplevel = Toplevel(self.tk) if self.drawer: self.drawer.frame.pack_forget() drawer = self.drawer=TkMoleculeDrawer.MoleculeDrawer(self.tk, m, name=smile) drawer.pack(expand=1, fill=BOTH)
def test(): from frowns import Smiles strings = ["Cl/C(F)=C(Br)/I", #"Cl\C)(F)=C(Br)\I", <- fix parsing bug #"Cl\C(\F)=C(/Br)\I", "Cl\C(F)=C(Br)\I", "Cl\C(F)=C(Br)/I", "Cl/C(F)=C(Br)\I" ] for s in strings: print s m = Smiles.smilin(s) assignStereo(m)
def testPath(): from frowns import Smiles mol = Smiles.smilin("C1CCCC1CCCC2CCCC3CCC3CCC2") rings = {} spans = [Path(mol.atoms[0], rings)] while spans: new = [] for span in spans: new += span.next() if len(rings) == 1: break if len(rings) == 1: break spans = new print rings
def test(): from frowns import Smiles import time h = BuildMatcher() for smi in ["C", "CC", "c", "C(N)O", "[O]", "c1ccccc1", ]: matcher = compile(smi) print matcher.dump() smiles = Smiles.smilin(smi) pathset = matcher.match(smiles)
def test(): from frowns import Smiles import time h = BuildMatcher() for smi in [ "C", "CC", "c", "C(N)O", "[O]", "c1ccccc1", ]: matcher = compile(smi) print matcher.dump() smiles = Smiles.smilin(smi) pathset = matcher.match(smiles)
from frowns import Smiles from frowns.perception import figueras badsmi = "C1=CC(=C2C=CC=C(N=CC34C5=C6C7=C3[Fe]456789%10%11C%12C8=C9C%10=C%11%12)C2=C1)N=CC%13%14C%15=C%16C%17=C%13[Fe]%14%15%16%17%18%19%20%21C%22C%18=C%19C%20=C%21%22" m1 = Smiles.smilin(badsmi, transforms=[figueras.sssr]) m2 = Smiles.smilin(badsmi) print len(m1.cycles) print len(m2.cycles)
print >> ofile, "\tatom%s -- atom%s;" % (atom1.handle, atom2.handle) print >> ofile, "}" return ofile.getvalue() if __name__ == '__main__': from frowns import Smiles # read in a molecule smiles = [ "c1ccccc1C=O", "c1ccc2cc1cccc2", "CCN", "CCCC(=O)NNCC", "CCC(CC)([CH](OC(N)=O)C1=CC=CC=C1)C2=CC=CC=C2", "ON=C(CC1=CC=CC=C1)[CH](C#N)C2=CC=CC=C2", "C1=CC=C(C=C1)C(N=C(C2=CC=CC=C2)C3=CC=CC=C3)C4=CC=CC=C4", ] mol_list = [] for smile in smiles: mol = Smiles.smilin(smile) mol.name = smile mol_list.append(mol) f = open('frowns.dot', 'w') f.write(generate_dot(mol_list))
molecule = fixBonds(molecule, pyroleLike) # add implicit hydrogens return addHydrogens(molecule, usedPyroles) if __name__ == "__main__": smiles = 'C1=CC(NC=C2)=C2C=C1' smiles = 'C1=CC(NC=C2)=C2C=C1' smiles = 'C1C=C[NH]2C=1C=CC=C2' smiles = 'C1[NH]C=CC=1CCC2C=CC=CC=2' #smiles = 'C1NC=CC=1' smiles = 'c1ccccc1' smiles = 'CC1=CC=CC2=NC=C(C)C(=C12)Cl' smiles = 'O=n1ccccc1' #smiles = 'O=N1=CC=CC=C1' from frowns import Smiles import RingDetection print smiles, mol = Smiles.smilin(smiles, transforms=[RingDetection.sssr, aromatize]) print '->', mol.cansmiles() print "atoms" for atom in mol.atoms: print "\t", atom.symbol, atom.valences, atom.hcount, atom.sumBondOrders( ), atom.charge, atom.aromatic print "bonds" for bond in mol.bonds: print "\t", bond.bondtype, bond.bondorder, bond.aromatic
from frowns.perception import sssr, TrustedSmiles from frowns import Smiles for smiles in ["c1ccccc1", "c1cc1CCc2cc2"]: m = Smiles.smilin(smiles, transforms=[sssr.sssr, TrustedSmiles.trusted_smiles]) print m.cansmiles() print m.arbsmarts() for bond in m.bonds: print bond.fixed, bond.symbol, bond.bondorder fusedrings = "c12c3c(cc(c(Cl)c3oc2c(Cl)ccc1Cl)Cl)Cl" for smiles in [fusedrings, 'c12[nH]c(c3ccc(CC)cc3)[nH0]c2[nH0]ccc1']: print "*" * 44 m = Smiles.smilin(smiles, transforms=[sssr.sssr, TrustedSmiles.trusted_smiles]) print m.cansmiles() print m.arbsmarts() m = Smiles.smilin(smiles) print m.cansmiles() print m.arbsmarts()
from frowns import Smiles mol = Smiles.smilin("c1ccccc1") print mol.cansmiles() print "atoms" for atom in mol.atoms: print atom.symbol, atom.hcount, atom.aromatic print "bonds" for bond in mol.bonds: print bond.bondorder, bond.bondtype
from bsddb3 import dbshelve from frowns import Smiles, Smarts, Fingerprint # ################################################################ # load database (this only needs to be done once # you can comment this out at a later data # ################################################################ # this is a persistent disk cache cache = dbshelve.open("FOO.shelve") molecules = ["CCCN", "c1ccccc1CCN", "C#C(N)CCc1ccccc1CCc1ccccc1"] for m in molecules: mol = Smiles.smilin(m) fp = Fingerprint.generateFingerprint(mol) # cache the fingerprint using the canonical smiles # as the key and the fingerprint object as the value # shelves can store any picklable object! cache[mol.cansmiles()] = fp cache.close() # ################################################################## # Iterate through database to see which molecules we need to # do a full substructure search on # ################################################################## cache = dbshelve.open("FOO.shelve", 'r') query = "CCCN" # this should reject molecule #2 above testFP = Fingerprint.generateFingerprint(Smiles.smilin(query))
molecule = fixBonds(molecule, pyroleLike) # add implicit hydrogens return addHydrogens(molecule, usedPyroles) if __name__ == "__main__": smiles = 'C1=CC(NC=C2)=C2C=C1' smiles = 'C1=CC(NC=C2)=C2C=C1' smiles = 'C1C=C[NH]2C=1C=CC=C2' smiles = 'C1[NH]C=CC=1CCC2C=CC=CC=2' #smiles = 'C1NC=CC=1' smiles = 'c1ccccc1' smiles = 'CC1=CC=CC2=NC=C(C)C(=C12)Cl' smiles = 'O=n1ccccc1' #smiles = 'O=N1=CC=CC=C1' from frowns import Smiles import RingDetection print smiles, mol = Smiles.smilin(smiles, transforms=[RingDetection.sssr, aromatize]) print '->', mol.cansmiles() print "atoms" for atom in mol.atoms: print "\t", atom.symbol, atom.valences, atom.hcount, atom.sumBondOrders(), atom.charge, atom.aromatic print "bonds" for bond in mol.bonds: print "\t", bond.bondtype, bond.bondorder, bond.aromatic
from frowns import Smiles mol = Smiles.smilin("c1ccccc1CCC1CC1") index = 0 for cycle in mol.cycles: print "cycle", index print "\t", cycle.atoms print "\t", cycle.bonds index = index + 1
atoms, bonds = toposort(atoms) rings.append((atoms, bonds)) cycles.append(Cycle(atoms, bonds)) molecule.rings = rings molecule.cycles = cycles return molecule if __name__ == "__main__": from frowns import Smiles import time data = open("../Working/frowns/test/data/NCI_small").read() count = 0 i = 0 for line in data.split("\n"): i += 1 smiles = line.split()[0] m = Smiles.smilin(smiles) t1 = time.time() m = sssr(m) t2 = time.time() count += (t2-t1) assert len(m.cycles) == len(m.rings), "failed %s in %f average"%(float(count)/i) print "average sssr", float(count)/i
import Components def computeMW(mol): """mol -> mw of largest fragment, mw of total molecule""" fragments = [] total = 0.0 if not mol.atoms: return 0.0, 0.0 for atoms, bonds in Components.components(mol): mw = 0.0 for atom in atoms: mw += atom.mass + atom.hcount fragments.append(mw) total += mw largest = max(fragments) return largest, total if __name__ == "__main__": from frowns import Smiles mol = Smiles.smilin("CCC.NNN.Br") print computeMW(mol)
#is the coordinates of hydrogen stored somewhere in the #atom the hydrogen is attached to? ## hatom.x = ## hatom.y = ## hatom.z = #does the hcount need to be changed? ## atom.hcount -= 1 mol.add_atom(hatom) bond = Bond() mol.add_bond(bond, atom, hatom) #reset atom indices index = 0 for atom in mol.atoms: atom.index = index index += 1 mol.explicitHydrogens = 1 #change flag to let know that hydrogens are explicit in this mol return mol from frowns import Smiles m = Smiles.smilin("CCCCc1ccccc1") m.explicitHydrogens = 0 addHydrogens(m) print m.cansmiles()
assert maxdepth - 1 == len(integersPerAtoms) def createFP(self, molecule): p = SplitFingerprint(self.maxdepth, self.integersPerAtoms) paths = generatePaths(molecule, maxdepth=self.maxdepth) paths.sort() for length, s in paths: p.addPath(length, s) return p if __name__ == "__main__": from frowns import Smiles mol = Smiles.smilin("CCCc1cc[nH]c1") mol2 = Smiles.smilin("c1cc[nH]c1") paths = generatePaths(mol) pathLengths = {} for p in paths: l, s = p pathLengths[l] = pathLengths.get(l, []) + [s] generator = SplitFingerprintGenerator() sp = generator.createFP(mol) sp2 = generator.createFP(mol2) assert sp in sp assert sp2 in sp
from frowns import Smarts, Smiles mol = Smiles.smilin('O=[N+]([O-])c1ccc(NC(C(C)(C)O)=O)cc1') pattern = Smarts.compile('[cH0]-[!C;!N]') match = pattern.match(mol) if match: for path in match: a1, a2 = path.atoms b1 = path.bonds[0] print a1, a1.index, a1.aromatic, b1.aromatic, b1.bondtype, b1.bondorder, a2, a2.index, a2.aromatic
from frowns import Smiles mol = Smiles.smilin("C1CC=1") print mol.arbsmiles()
def generatePaths(molecule, maxdepth=5, name_atom=name_atom, name_bond=name_bond, name_ring_atom=name_ring_atom, name_ring_bond=name_ring_bond, make_rpath=0): """(molecule, maxdepth, *name_atom, *name_bond) -> linear paths Generate all linear paths through a molecule up to maxdepth change name_atom and name_bond to name the atoms and bonds in the molecule name_atom and name_bond must return a stringable value""" paths = {} for atom in molecule.atoms: _bfswalk(atom, {atom:1}, [name_atom(atom)], [name_ring_atom(atom)], paths, 1, maxdepth, name_atom, name_bond, name_ring_atom, name_ring_bond, make_rpath) return paths.keys() if __name__ == "__main__": from frowns import Smiles mol = Smiles.smilin("CCNc1cccc1") paths = generatePaths(mol) print len(paths) print paths ONE_STRING_PER_PATH = 1 paths = generatePaths(mol) print len(paths) print paths
name_atom=name_atom, name_bond=name_bond, name_ring_atom=name_ring_atom, name_ring_bond=name_ring_bond, make_rpath=0): """(molecule, maxdepth, *name_atom, *name_bond) -> linear paths Generate all linear paths through a molecule up to maxdepth change name_atom and name_bond to name the atoms and bonds in the molecule name_atom and name_bond must return a stringable value""" paths = {} for atom in molecule.atoms: _bfswalk(atom, {atom: 1}, [name_atom(atom)], [name_ring_atom(atom)], paths, 1, maxdepth, name_atom, name_bond, name_ring_atom, name_ring_bond, make_rpath) return paths.keys() if __name__ == "__main__": from frowns import Smiles mol = Smiles.smilin("CCNc1cccc1") paths = generatePaths(mol) print len(paths) print paths ONE_STRING_PER_PATH = 1 paths = generatePaths(mol) print len(paths) print paths
import sys sys.path.append("/Users/stockwel/Working") from frowns import Smiles import time from frowns.perception import RingDetection, BasicAromaticity, figueras, pysssr transforms = [figueras.sssr, BasicAromaticity.aromatize] tests = [x.split()[0] for x in open("data/NCI_small")][0:100] t1 = time.time() for smiles in tests: m = Smiles.smilin(smiles, transforms) t2 = time.time() time1 = (t2-t1)/len(tests) print "start", t1 print "end", t2 print "elapsed", t2-t1 print "number of smiles", len(tests) print "average molecule generation", time1 transforms = [pysssr.sssr, BasicAromaticity.aromatize] t1 = time.time() for smiles in tests:
from Tkinter import * from frowns.Depict.MoleculeDock import MoleculeDock from frowns import Smiles # read in a molecule smiles = ["c1ccccc1C=O", "c1ccc2cc1cccc2", "CCN", "CCCC(=O)NNCC"] # create the moleculedock widget and place it # into a tk window tk = top = Tk() m = MoleculeDock(top) m.pack(fill=BOTH, expand=1) for smile in smiles: mol = Smiles.smilin(smile) m.addMolecule(mol) mainloop()
from frowns import Smiles m = Smiles.smilin("N[C@](C)(F)C(=O)O") print "initial smiles:", m.arbsmiles(isomeric=1) print "canonical smiles:", m.cansmiles(isomeric=1) print m = Smiles.smilin("[C@H](C)(F)(O)") print "initial smiles:", m.arbsmiles(isomeric=1) print "canonical smiles:", m.cansmiles(isomeric=1)
while 1: to_remove = [] for atom in m.atoms: if atom.symbol == "C" and len(atom.bonds) == 1: to_remove.append(atom) if not to_remove: break for atom in to_remove: m.remove_atom(atom) return m m = Smiles.smilin("c1ccccc1CCNc1cccc1CCC") print m.cansmiles() removeTerminalAtoms(m) smarts = m.arbsmarts() print smarts pat = Smarts.compile(smarts) assert pat.match(m) smiles = [] file = open("F:\\Chemical Libraries\\Libraries to Purchase\\Nat_425.sdf") reader = MDL.mdlin(file) mol = reader.next()
if atom.aromatic: # assume the combined bondorder is 3 atom.hybrid = SP2 continue symbol = atom.symbol hcount = atom.valences[0] - atom.sumBondOrders() connections = len(atom.bonds) + hcount charge = atom.charge if atom.symbol in ["C", "N"] and connections == 2: charge = ANY atom.hybrid = _hybrid.get((symbol, connections, charge), "") #print atom, `atom`, hcount, atom.hybrid if __name__ == "__main__": from frowns import Smiles from frowns.perception import TrustedSmiles, sssr smiles = "CC(=O)OC1C(N(c2c(CC1c1ccc(OC)cc1)cc(cc2)Oc1ccccc1)CCN(C)C)=O" smiles = "O=C1NC(N)=NC2=C1N=CNC2" #smiles = "O=C1C=CC(=O)C=C1" print smiles mol = Smiles.smilin(smiles, [sssr.sssr]) getHybridAtoms(mol) for cycle in mol.cycles: print[(atom, atom.symbol, atom.hybrid) for atom in cycle.atoms]
#atom the hydrogen is attached to? ## hatom.x = ## hatom.y = ## hatom.z = #does the hcount need to be changed? ## atom.hcount -= 1 mol.add_atom(hatom) bond = Bond() mol.add_bond(bond, atom, hatom) #reset atom indices index = 0 for atom in mol.atoms: atom.index = index index += 1 mol.explicitHydrogens = 1 #change flag to let know that hydrogens are explicit in this mol return mol from frowns import Smiles m = Smiles.smilin("CCCCc1ccccc1") m.explicitHydrogens = 0 addHydrogens(m) print m.cansmiles()
def test(): from frowns import Smiles import RingDetection import sssr as sssr2 import time from frowns.Canonicalization import Disambiguate, Traverse ##mol = Smiles.smilin("C12C3C4C1C5C4C3C25CCCCCC12C3C4C1C5C4C3C25") ##mol1 = Smiles.smilin("C1O[CH]1C2=CC=CC=C2", ## transforms = []) ##print mol1.cansmiles() smiles = "COC(=O)[CH]1C2CCC(CC2)[CH]1C(=O)OCC" smiles = "CC1(C)[CH]2CC[CH](CC(O)=O)[CH]1C2" smiles = "C[CH]1C(=O)O[CH]2CCN3CC=C(COC(=O)[C](C)(O)[C]1(C)O)[CH]23" #smiles = "CC1=CC(=O)C=CC1=O" smiles = "NC1=CC2=C(C=C1)C(=O)C3=C(C=CC=C3)C2=O" smiles = "COC1=CC2=C(C=C1OC)[C]34CCN5CC6=CCO[CH]7CC(=O)N2[CH]3[CH]7[CH]6C[CH]45.OS(O)(=O)=O" mol1 = Smiles.smilin(smiles, transforms = []) print mol1.cansmiles() NUM = 1 t1 = time.time() for i in range(NUM): sssr(mol1) t2 = time.time() print (t2-t1)/NUM symbols = [] for atom in mol1.atoms: symbols.append(atom.symbol) for atom in mol1.atoms: atom.symbol += ".%s."%atom.index atom.symorder = mol1.atoms.index(atom) index = 0 for cycle in mol1.cycles: print cycle.atoms print cycle.bonds for atom in cycle.atoms: atom.symbol += "<%s>"%index index += 1 print Traverse.draw(mol1)[0] for atom, symbol in zip(mol1.atoms, symbols): atom.symbol = symbol for atom in mol1.atoms: atom.symbol += ".%s."%atom.index atom.symorder = mol1.atoms.index(atom) t1 = time.time() for i in range(NUM): RingDetection.sssr(mol1) t2 = time.time() print (t2-t1)/NUM index = 0 for cycle in mol1.cycles: print cycle.atoms print cycle.bonds for atom in cycle.atoms: atom.symbol += "<%s>"%index index += 1 print Traverse.draw(mol1)[0]
def createFP(self, molecule): p = SplitFingerprint(self.maxdepth, self.integersPerAtoms) paths = generatePaths(molecule, maxdepth=self.maxdepth) paths.sort() for length, s in paths: p.addPath(length, s) return p if __name__ == "__main__": from frowns import Smiles mol = Smiles.smilin("CCCc1cc[nH]c1") mol2 = Smiles.smilin("c1cc[nH]c1") paths = generatePaths(mol) pathLengths = {} for p in paths: l, s = p pathLengths[l] = pathLengths.get(l, []) + [s] generator = SplitFingerprintGenerator() sp = generator.createFP(mol) sp2 = generator.createFP(mol2) assert sp in sp assert sp2 in sp
import time from frowns import Smiles from frowns import Smarts mol = Smiles.smilin("CCCCC(C)CCCC(C)CCCCCC(C)C(C)CCCCCC(C)CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCN") pat = Smarts.compile("C*") print len(pat.match(mol)) pat2 = Smarts.compile("[#6]") t1 = time.time() print len(pat2.match(mol)) t2 = time.time() print t2-t1 t1 = time.time() print len(pat2.match(mol)) t2 = time.time() print t2-t1 print mol.vfgraph
from frowns import Smiles m = Smiles.smilin("[CH0]") assert m.cansmiles() == "[C]" m = Smiles.smilin("C") assert m.cansmiles() == "C"
if atom.symbol == "C" and ( (len(atom.bonds) == 4 and atom.hcount == 0) or \ (len(atom.bonds) == 3 and atom.hcount == 1) ): atomsToCheck.append(atom) chiralAtoms = [] for atom in atomsToCheck: types = {} for attachedAtom in atom.oatoms: symbol = attachedAtom.symbol if symbol in types: if bfsCheckAtoms(atom): chiralAtoms.append(atom) break types[symbol] = 1 else: chiralAtoms.append(atom) return chiralAtoms if __name__ == "__main__": from frowns import Smiles for smiles in ["C(N)(O)(S)", "C(N)(O)(S)(C)", "C(N)(C)(O)[Fe]"]: m = Smiles.smilin(smiles) print getStereoCenters(m)
from frowns.perception import sssr, TrustedSmiles from frowns import Smiles s = "c12[nH]c(c3ccc(CC)cc3)[nH0]c2[nH0]ccc1" m = Smiles.smilin(s, transforms=[sssr.sssr, TrustedSmiles.trusted_smiles]) print m.arbsmarts() for atom in m.atoms: print atom.symbol, atom.hcount, atom.explicit_hcount
from frowns import Smiles print "*"*33 print "benzene with default transforms" mol = Smiles.smilin("c1ccccc1") print mol.cansmiles() print "atoms" for atom in mol.atoms: print "\tsymbol %s hcount %s aromatic %s"%( atom.symbol, atom.hcount, atom.aromatic) print "bonds" for bond in mol.bonds: print "\tbondorder %s, bondtype %s fixed %s"%( bond.bondorder, bond.bondtype, bond.fixed) print "*"*33 print "benzene with no transforms" mol = Smiles.smilin("c1ccccc1", transforms=[]) print mol.cansmiles() print "atoms" for atom in mol.atoms: print "\tsymbol %s hcount %s aromatic %s"%( atom.symbol, atom.hcount, atom.aromatic) print "bonds" for bond in mol.bonds: print "\tbondorder %s, bondtype %s fixed %s"%( bond.bondorder, bond.bondtype, bond.fixed)
from frowns import Smiles, Smarts for smiles in ['OC1C=CC(=O)C=C1', 'c1ccccc1']: mol = Smiles.smilin(smiles) print mol.cansmiles() print "with square brackets" pattern = Smarts.compile('OC(C)[A]') match = pattern.match(mol) if match: for path in match: print path.atoms print print "without square brackets" pattern2 = Smarts.compile('O=C(C)A') match2 = pattern2.match(mol) if match2: for path2 in match2: print path2.atoms m = Smiles.smilin("c1ccccc1") p = Smarts.compile("c1ccccc1") assert p.match(m)
from frowns import Smiles from frowns import Smarts mol = Smiles.smilin("CCN") pattern = Smarts.compile("CCN") # simple match match = pattern.match(mol) assert match index = 1 for path in match: print "match", index print "\tatoms", path.atoms print "\tbond", path.bonds index = index + 1 print "*" * 33 # more complicated match pattern = Smarts.compile("C*") match = pattern.match(mol) assert match index = 1 for path in match: print "match", index print "\tatoms", path.atoms print "\tbond", path.bonds index = index + 1 print "*" * 33 pattern = Smarts.compile("[!N]-[!C]") match = pattern.match(mol)
def test(): from frowns import Smiles import RingDetection import sssr as sssr2 import time from frowns.Canonicalization import Disambiguate, Traverse ##mol = Smiles.smilin("C12C3C4C1C5C4C3C25CCCCCC12C3C4C1C5C4C3C25") ##mol1 = Smiles.smilin("C1O[CH]1C2=CC=CC=C2", ## transforms = []) ##print mol1.cansmiles() smiles = "COC(=O)[CH]1C2CCC(CC2)[CH]1C(=O)OCC" smiles = "CC1(C)[CH]2CC[CH](CC(O)=O)[CH]1C2" smiles = "C[CH]1C(=O)O[CH]2CCN3CC=C(COC(=O)[C](C)(O)[C]1(C)O)[CH]23" #smiles = "CC1=CC(=O)C=CC1=O" smiles = "NC1=CC2=C(C=C1)C(=O)C3=C(C=CC=C3)C2=O" smiles = "COC1=CC2=C(C=C1OC)[C]34CCN5CC6=CCO[CH]7CC(=O)N2[CH]3[CH]7[CH]6C[CH]45.OS(O)(=O)=O" mol1 = Smiles.smilin(smiles, transforms=[]) print mol1.cansmiles() NUM = 1 t1 = time.time() for i in range(NUM): sssr(mol1) t2 = time.time() print(t2 - t1) / NUM symbols = [] for atom in mol1.atoms: symbols.append(atom.symbol) for atom in mol1.atoms: atom.symbol += ".%s." % atom.index atom.symorder = mol1.atoms.index(atom) index = 0 for cycle in mol1.cycles: print cycle.atoms print cycle.bonds for atom in cycle.atoms: atom.symbol += "<%s>" % index index += 1 print Traverse.draw(mol1)[0] for atom, symbol in zip(mol1.atoms, symbols): atom.symbol = symbol for atom in mol1.atoms: atom.symbol += ".%s." % atom.index atom.symorder = mol1.atoms.index(atom) t1 = time.time() for i in range(NUM): RingDetection.sssr(mol1) t2 = time.time() print(t2 - t1) / NUM index = 0 for cycle in mol1.cycles: print cycle.atoms print cycle.bonds for atom in cycle.atoms: atom.symbol += "<%s>" % index index += 1 print Traverse.draw(mol1)[0]
from frowns import Smiles from frowns import Smarts from frowns.perception import sssr from frowns.perception import RingDetection ## '*' is ok mol=Smiles.smilin("SCCCCSCCCC",transforms=[RingDetection.sssr]) #pattern=Smarts.compile("S*CC") ##!! '~' has problem pattern=Smarts.compile("S~C~C") ##!! pattern can't match itself mol=Smiles.smilin("C[CH](C1=CC=CC=C1)[C](C)(C#N)C2=CC=CC=C2") pattern = Smarts.compile(mol.arbsmarts()) print mol.arbsmarts() pattern=Smarts.compile("CC(C1=CC=CC=C1)C(C)(C#N)C2=CC=CC=C2") match=pattern.match(mol) assert match index=1 for path in match: print "match",index print "\tatoms",path.atoms print "\tbond",path.bonds index=index+1
import frowns.Fingerprint from frowns import Smiles patterns_and_targets = ( ("CCN", ("CCN", "CCNCC", "c1cccc1CCN")), ) for pattern, targets in patterns_and_targets: pattern_molecule = Smiles.smilin(pattern) pfp = frowns.Fingerprint.generateFingerprint(pattern_molecule) for target in targets: mol = Smiles.smilin(target) molfp = \ frowns.Fingerprint.generateFingerprint(mol) # pfp must be "in" molfp for test to pass assert pfp in molfp, "match %s is not in target %s!"%(pattern, target)
atom.hybrid = SP2 continue symbol = atom.symbol hcount = atom.valences[0] - atom.sumBondOrders() connections = len(atom.bonds) + hcount charge = atom.charge if atom.symbol in ["C", "N"] and connections == 2: charge = ANY atom.hybrid = _hybrid.get((symbol, connections, charge), "") #print atom, `atom`, hcount, atom.hybrid if __name__ == "__main__": from frowns import Smiles from frowns.perception import TrustedSmiles, sssr smiles = "CC(=O)OC1C(N(c2c(CC1c1ccc(OC)cc1)cc(cc2)Oc1ccccc1)CCN(C)C)=O" smiles = "O=C1NC(N)=NC2=C1N=CNC2" #smiles = "O=C1C=CC(=O)C=C1" print smiles mol = Smiles.smilin(smiles, [sssr.sssr]) getHybridAtoms(mol) for cycle in mol.cycles: print [(atom, atom.symbol, atom.hybrid) for atom in cycle.atoms]