Python DbModule.binaryHolder方法代码示例

# 需要导入模块: from rdkit.Dbase import DbModule [as 别名]
# 或者: from rdkit.Dbase.DbModule import binaryHolder [as 别名]
def ProcessMol(mol,typeConversions,globalProps,nDone,nameProp='_Name',nameCol='compound_id',
               redraw=False,keepHs=False,
               skipProps=False,addComputedProps=False,
               skipSmiles=False,
               uniqNames=None,namesSeen=None):
  if not mol:
    raise ValueError('no molecule')
  if keepHs:
    Chem.SanitizeMol(mol)
  try:
    nm = mol.GetProp(nameProp)
  except KeyError:
    nm = None
  if not nm:
    nm = 'Mol_%d'%nDone
  if uniqNames and nm in namesSeen:
    logger.error('duplicate compound id (%s) encountered. second instance skipped.'%nm)
    return None
  namesSeen.add(nm)
  row = [nm]
  if not skipProps:
    if addComputedProps:
      nHD=Lipinski.NumHDonors(mol)
      mol.SetProp('DonorCount',str(nHD))
      nHA=Lipinski.NumHAcceptors(mol)
      mol.SetProp('AcceptorCount',str(nHA))
      nRot=Lipinski.NumRotatableBonds(mol)
      mol.SetProp('RotatableBondCount',str(nRot))
      MW=Descriptors.MolWt(mol)
      mol.SetProp('AMW',str(MW))
      logp=Crippen.MolLogP(mol)
      mol.SetProp('MolLogP',str(logp))

    pns = list(mol.GetPropNames())
    pD={}
    for pi,pn in enumerate(pns):
      if pn.lower()==nameCol.lower(): continue
      pv = mol.GetProp(pn).strip()
      if pv.find('>')<0 and pv.find('<')<0:
        colTyp = globalProps.get(pn,2)
        while colTyp>0:
          try:
            tpi = typeConversions[colTyp][1](pv)
          except:
            colTyp-=1
          else:
            break
        globalProps[pn]=colTyp
        pD[pn]=typeConversions[colTyp][1](pv)
      else:
        pD[pn]=pv
  else:
    pD={}
  if redraw:
    AllChem.Compute2DCoords(m)
  if not skipSmiles:
    row.append(Chem.MolToSmiles(mol,True))
  row.append(DbModule.binaryHolder(mol.ToBinary()))
  row.append(pD)
  return row

# 需要导入模块: from rdkit.Dbase import DbModule [as 别名]
# 或者: from rdkit.Dbase.DbModule import binaryHolder [as 别名]
  def test9(self):
    " substructure counts "
    curs = self.conn.GetCursor()

    res = curs.execute("SELECT rd_substructcount('O','OCCC(=O)O')").fetchone()
    self.failUnless(res[0]==3)
    res = curs.execute("SELECT rd_substructcount('N','OCCC(=O)O')").fetchone()
    self.failUnless(res[0]==0)
    res = curs.execute("SELECT rd_substructcount('[O,S]','SCCC(=O)O')").fetchone()
    self.failUnless(res[0]==3)
    res = curs.execute("SELECT rd_substructcount('[O,S]','OCCC(=O)O')").fetchone()
    self.failUnless(res[0]==3)
    
    self.failUnlessRaises(DataError,
                          lambda : curs.execute("SELECT rd_substructcount('QcC','c1ccccc1C');"))
    curs = self.conn.GetCursor()
    self.failUnlessRaises(DataError,
                          lambda : curs.execute("SELECT rd_substructcount('QcC','c1ccccc1C');"))
    curs = self.conn.GetCursor()
    self.failUnlessRaises(DataError,
                          lambda : curs.execute("SELECT rd_substructcount('cC','Qc1ccccc1C');"))
    curs = self.conn.GetCursor()
    self.failUnlessRaises(DataError,
                          lambda : curs.execute("SELECT rd_substructcount('nC','c1ccccn1C');"))
    curs = self.conn.GetCursor()


    pkl1 = DbModule.binaryHolder(Chem.MolFromSmiles('O').ToBinary())
    pkl2 = DbModule.binaryHolder(Chem.MolFromSmiles('OCCC(=O)O').ToBinary())
    cmd = "SELECT rd_substructcount(cast (%s as bytea),cast (%s as bytea))"
    res = curs.execute(cmd,(pkl1,pkl2)).fetchone()
    self.failUnless(res[0]==3)
    pkl1 = DbModule.binaryHolder(Chem.MolFromSmiles('N').ToBinary())
    res = curs.execute(cmd,(pkl1,pkl2)).fetchone()
    self.failUnless(res[0]==0)

    pkl1 = DbModule.binaryHolder(Chem.MolFromSmiles('O').ToBinary())
    curs = self.conn.GetCursor()
    self.failUnlessRaises(DataError,
                          lambda : curs.execute(cmd,('',pkl2)))
    curs = self.conn.GetCursor()
    self.failUnlessRaises(DataError,
                          lambda : curs.execute(cmd,(pkl1,'')))
    curs = self.conn.GetCursor()
    self.failUnlessRaises(DataError,
                          lambda : curs.execute(cmd,('','')))

# 需要导入模块: from rdkit.Dbase import DbModule [as 别名]
# 或者: from rdkit.Dbase.DbModule import binaryHolder [as 别名]

#.........这里部分代码省略.........
    idCol = 0
    smiCol = 1
  elif details.inFileName and details.useSmiles:
    from rdkit.ML.Data import DataUtils
    conn = None
    if not details.idName:
      details.idName = 'ID'
    try:
      dataSet = DataUtils.TextFileToData(details.inFileName,
                                         onlyCols=[details.idName, details.smilesName])
    except IOError:
      import traceback
      error('Problems reading from file %s\n' % (details.inFileName))
      traceback.print_exc()

    idCol = 0
    smiCol = 1
  elif details.inFileName and details.useSD:
    conn = None
    dataset = None
    if not details.idName:
      details.idName = 'ID'
    dataSet = []
    try:
      s = Chem.SDMolSupplier(details.inFileName)
    except Exception:
      import traceback
      error('Problems reading from file %s\n' % (details.inFileName))
      traceback.print_exc()
    else:
      while 1:
        try:
          m = s.next()
        except StopIteration:
          break
        if m:
          dataSet.append(m)
          if reportFreq > 0 and not len(dataSet) % reportFreq:
            message('Read %d molecules\n' % (len(dataSet)))
            if details.maxMols > 0 and len(dataSet) >= details.maxMols:
              break

    for i, mol in enumerate(dataSet):
      if mol.HasProp(details.idName):
        nm = mol.GetProp(details.idName)
      else:
        nm = mol.GetProp('_Name')
      dataSet[i] = (nm, mol)
  else:
    dataSet = None

  fps = None
  if dataSet and not details.useSD:
    data = dataSet.GetNamedData()
    if not details.molPklName:
      fps = apply(FingerprintsFromSmiles, (data, idCol, smiCol), details.__dict__)
    else:
      fps = apply(FingerprintsFromPickles, (data, idCol, smiCol), details.__dict__)
  elif dataSet and details.useSD:
    fps = apply(FingerprintsFromMols, (dataSet, ), details.__dict__)

  if fps:
    if details.outFileName:
      outF = open(details.outFileName, 'wb+')
      for i in range(len(fps)):
        cPickle.dump(fps[i], outF)
      outF.close()
    dbName = details.outDbName or details.dbName
    if details.outTableName and dbName:
      from rdkit.Dbase.DbConnection import DbConnect
      from rdkit.Dbase import DbUtils, DbModule
      conn = DbConnect(dbName)
      #
      #  We don't have a db open already, so we'll need to figure out
      #    the types of our columns...
      #
      colTypes = DbUtils.TypeFinder(data, len(data), len(data[0]))
      typeStrs = DbUtils.GetTypeStrings([details.idName, details.smilesName], colTypes,
                                        keyCol=details.idName)
      cols = '%s, %s %s' % (typeStrs[0], details.fpColName, DbModule.binaryTypeName)

      # FIX: we should really check to see if the table
      #  is already there and, if so, add the appropriate
      #  column.

      #
      # create the new table
      #
      if details.replaceTable or \
         details.outTableName.upper() not in [x.upper() for x in conn.GetTableNames()]:
        conn.AddTable(details.outTableName, cols)

      #
      # And add the data
      #
      for ID, fp in fps:
        tpl = ID, DbModule.binaryHolder(fp.ToBinary())
        conn.InsertData(details.outTableName, tpl)
      conn.Commit()
  return fps

# 需要导入模块: from rdkit.Dbase import DbModule [as 别名]
# 或者: from rdkit.Dbase.DbModule import binaryHolder [as 别名]

#.........这里部分代码省略.........
  fpRows = []
  layeredRows = []
  descrRows = []
  pharm2DRows=[]
  gobbi2DRows=[]
  morganRows = []

  if not options.silent: logger.info('Generating fingerprints and descriptors:')
  molConn = DbConnect(os.path.join(options.outDir,options.molDbName))
  molCurs = molConn.GetCursor()
  if not options.skipSmiles:
    molCurs.execute('select guid,%s,smiles,molpkl from %s'%(options.molIdName,options.regName))
  else:
    molCurs.execute('select guid,%s,molpkl from %s'%(options.molIdName,options.regName))
  i=0
  while 1:
    try:
      tpl = molCurs.fetchone()
      molGuid = tpl[0]
      molId = tpl[1]
      pkl = tpl[-1]
      i+=1
    except:
      break
    if isinstance(pkl,(bytes,str)):
      mol = Chem.Mol(pkl)
    else:
      mol = Chem.Mol(str(pkl))
    if not mol: continue
     
    if options.doPairs:
      pairs = FingerprintUtils.BuildAtomPairFP(mol)
      torsions = FingerprintUtils.BuildTorsionsFP(mol)
      pkl1 = DbModule.binaryHolder(pairs.ToBinary())
      pkl2 = DbModule.binaryHolder(torsions.ToBinary())
      row = (molGuid,molId,pkl1,pkl2)
      pairRows.append(row)
    if options.doFingerprints:
      fp2 = FingerprintUtils.BuildRDKitFP(mol)
      pkl = DbModule.binaryHolder(fp2.ToBinary())
      row = (molGuid,molId,pkl)
      fpRows.append(row)
    if options.doLayered:
      words = LayeredOptions.GetWords(mol)
      row = [molGuid,molId]+words
      layeredRows.append(row)
    if options.doDescriptors:
      descrs= calc.CalcDescriptors(mol)
      row = [molGuid,molId]
      row.extend(descrs)
      descrRows.append(row)
    if options.doPharm2D:
      FingerprintUtils.sigFactory=sigFactory
      fp= FingerprintUtils.BuildPharm2DFP(mol)
      pkl = DbModule.binaryHolder(fp.ToBinary())
      row = (molGuid,molId,pkl)
      pharm2DRows.append(row)
    if options.doGobbi2D:
      FingerprintUtils.sigFactory=Gobbi_Pharm2D.factory
      fp= FingerprintUtils.BuildPharm2DFP(mol)
      pkl = DbModule.binaryHolder(fp.ToBinary())
      row = (molGuid,molId,pkl)
      gobbi2DRows.append(row)
    if options.doMorganFps:
      morgan = FingerprintUtils.BuildMorganFP(mol)
      pkl = DbModule.binaryHolder(morgan.ToBinary())

# 需要导入模块: from rdkit.Dbase import DbModule [as 别名]
# 或者: from rdkit.Dbase.DbModule import binaryHolder [as 别名]
  def test11(self):
    " descriptors "
    from rdkit.Chem import Crippen,Descriptors
    curs = self.conn.GetCursor()

    smi = "c1ncccc1"
    m = Chem.MolFromSmiles(smi)
    pkl= DbModule.binaryHolder(m.ToBinary())
    ref = Crippen.MolLogP(m, includeHs=True)
    res = curs.execute("SELECT rd_mollogp(%s)",(smi,)).fetchone()
    v = res[0]
    self.failUnlessAlmostEqual(ref,v,4)
    res = curs.execute("SELECT rd_mollogp(cast (%s as bytea))",(pkl,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)
    res = curs.execute("SELECT rd_mollogp(rd_molpickle(%s))",(smi,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)

    ref = Descriptors.MolWt(m)
    res = curs.execute("SELECT rd_molamw(%s)",(smi,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)
    res = curs.execute("SELECT rd_molamw(cast (%s as bytea))",(pkl,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)
    res = curs.execute("SELECT rd_molamw(rd_molpickle(%s))",(smi,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)



    smi = "CCOCC(C)(C)C"
    m = Chem.MolFromSmiles(smi)
    pkl= DbModule.binaryHolder(m.ToBinary())
    ref = Crippen.MolLogP(m,includeHs=1)
    res = curs.execute("SELECT rd_mollogp(%s)",(smi,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)
    res = curs.execute("SELECT rd_mollogp(cast (%s as bytea))",(pkl,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)
    res = curs.execute("SELECT rd_mollogp(rd_molpickle(%s))",(smi,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)

    ref = Descriptors.MolWt(m)
    res = curs.execute("SELECT rd_molamw(%s)",(smi,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)
    res = curs.execute("SELECT rd_molamw(cast (%s as bytea))",(pkl,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)
    res = curs.execute("SELECT rd_molamw(rd_molpickle(%s))",(smi,))
    v = res.fetchone()[0]
    self.failUnlessAlmostEqual(ref,v,4)


    self.failUnlessRaises(DataError,
                          lambda : curs.execute('select rd_mollogp(%s)',('',)))
    curs = self.conn.GetCursor()
    self.failUnlessRaises(DataError,
                          lambda : curs.execute('select rd_mollogp(%s)',('QC',)))
    curs = self.conn.GetCursor()
    self.failUnlessRaises(DataError,
                          lambda : curs.execute('select rd_mollogp(cast (%s as bytea))',('',)))
    curs = self.conn.GetCursor()
    self.failUnlessRaises(DataError,
                          lambda : curs.execute('select rd_mollogp(cast (%s as bytea))',('randomtext',)))

# 需要导入模块: from rdkit.Dbase import DbModule [as 别名]
# 或者: from rdkit.Dbase.DbModule import binaryHolder [as 别名]

#.........这里部分代码省略.........
    pairRows = []
    fpRows = []
    layeredRows = []
    descrRows = []
    pharm2DRows = []
    gobbi2DRows = []
    morganRows = []

    if not options.silent:
        logger.info("Generating fingerprints and descriptors:")
    molConn = DbConnect(os.path.join(options.outDir, options.molDbName))
    molCurs = molConn.GetCursor()
    if not options.skipSmiles:
        molCurs.execute("select guid,%s,smiles,molpkl from %s" % (options.molIdName, options.regName))
    else:
        molCurs.execute("select guid,%s,molpkl from %s" % (options.molIdName, options.regName))
    i = 0
    while 1:
        try:
            tpl = molCurs.fetchone()
            molGuid = tpl[0]
            molId = tpl[1]
            pkl = tpl[-1]
            i += 1
        except:
            break
        mol = Chem.Mol(str(pkl))
        if not mol:
            continue

        if options.doPairs:
            pairs = FingerprintUtils.BuildAtomPairFP(mol)
            torsions = FingerprintUtils.BuildTorsionsFP(mol)
            pkl1 = DbModule.binaryHolder(pairs.ToBinary())
            pkl2 = DbModule.binaryHolder(torsions.ToBinary())
            row = (molGuid, molId, pkl1, pkl2)
            pairRows.append(row)
        if options.doFingerprints:
            fp2 = FingerprintUtils.BuildRDKitFP(mol)
            pkl = DbModule.binaryHolder(fp2.ToBinary())
            row = (molGuid, molId, pkl)
            fpRows.append(row)
        if options.doLayered:
            words = LayeredOptions.GetWords(mol)
            row = [molGuid, molId] + words
            layeredRows.append(row)
        if options.doDescriptors:
            descrs = calc.CalcDescriptors(mol)
            row = [molGuid, molId]
            row.extend(descrs)
            descrRows.append(row)
        if options.doPharm2D:
            FingerprintUtils.sigFactory = sigFactory
            fp = FingerprintUtils.BuildPharm2DFP(mol)
            pkl = DbModule.binaryHolder(fp.ToBinary())
            row = (molGuid, molId, pkl)
            pharm2DRows.append(row)
        if options.doGobbi2D:
            FingerprintUtils.sigFactory = Gobbi_Pharm2D.factory
            fp = FingerprintUtils.BuildPharm2DFP(mol)
            pkl = DbModule.binaryHolder(fp.ToBinary())
            row = (molGuid, molId, pkl)
            gobbi2DRows.append(row)
        if options.doMorganFps:
            morgan = FingerprintUtils.BuildMorganFP(mol)
            pkl = DbModule.binaryHolder(morgan.ToBinary())