Python logger.info函数代码示例

def dividetask(data,task,silent=True):
    data=mpi.broadcast(mpi.world,data,0)

    nProcs = mpi.world.size
    chunkSize=len(data)//nProcs
    extraBits =len(data)%nProcs

    res=[]
    allRes=[]
    # the root node handles the extra pieces:
    if mpi.world.rank == 0:
        for i in range(extraBits):
          elem=data[i]
          res.append(task(elem))
          if not silent:
              logger.info('task(%d) done %d'%(mpi.world.rank,i+1))
    pos=extraBits+mpi.world.rank*chunkSize;
    for i in range(chunkSize):
        elem=data[pos]
        pos += 1
        res.append(task(elem))
        if not silent:
            logger.info('task(%d) done %d'%(mpi.world.rank,i+1))
    if mpi.world.rank==0:
        tmp=mpi.gather(mpi.world,res,0)
        for res in tmp: allRes.extend(res)
    else:
        mpi.gather(mpi.world,res,0)
    return allRes

def GetNeighborLists(probes,topN,pool,
                     simMetric=DataStructs.DiceSimilarity,
                     silent=False):
  probeFps = [x[1] for x in probes]
  validProbes = [x for x in range(len(probeFps)) if probeFps[x] is not None]
  validFps=[probeFps[x] for x in validProbes]
  from rdkit.DataStructs.TopNContainer import TopNContainer
  nbrLists = [TopNContainer(topN) for x in range(len(probeFps))]

  nDone=0
  for nm,fp in pool:
    nDone+=1
    if not silent and not nDone%1000: logger.info('  searched %d rows'%nDone)
    if(simMetric==DataStructs.DiceSimilarity):
      scores = DataStructs.BulkDiceSimilarity(fp,validFps)
      for i,score in enumerate(scores):
        nbrLists[validProbes[i]].Insert(score,nm)
    elif(simMetric==DataStructs.TanimotoSimilarity):
      scores = DataStructs.BulkTanimotoSimilarity(fp,validFps)
      for i,score in enumerate(scores):
        nbrLists[validProbes[i]].Insert(score,nm)
    else:
      for i in range(len(probeFps)):
        pfp = probeFps[i]
        if pfp is not None:
          score = simMetric(probeFps[i],fp)
          nbrLists[i].Insert(score,nm)
  return nbrLists

    def testSpingFile(self):
        try:
            from rdkit.Chem.Draw.spingCanvas import Canvas
        except ImportError:
            logger.info("Skipping sping test")
            return
        os.environ["RDKIT_CANVAS"] = "sping"

        foo, fn = tempfile.mkstemp(suffix=".png")
        foo = None
        self.failUnlessEqual(os.path.getsize(fn), 0)

        Draw.MolToFile(self.mol, fn)

        self.failIfEqual(os.path.getsize(fn), 0)
        try:
            os.unlink(fn)
        except:
            pass

  def testSpingFile(self):
    try:
      from rdkit.Chem.Draw.spingCanvas import Canvas
    except ImportError:
      logger.info("Skipping sping test")
      return
    os.environ['RDKIT_CANVAS']='sping'

    foo,fn=tempfile.mkstemp(suffix='.png')
    foo=None
    self.assertEqual(os.path.getsize(fn),0)

    Draw.MolToFile(self.mol,fn)

    self.assertNotEqual(os.path.getsize(fn),0)
    try:
      os.unlink(fn)
    except Exception:
      pass

  def testCairoFile(self):
    try:
      from rdkit.Chem.Draw.cairoCanvas import Canvas
    except ImportError:
      logger.info("Skipping cairo test")
      return
    os.environ['RDKIT_CANVAS']='cairo'

    foo,fn=tempfile.mkstemp(suffix='.png')
    foo=None
    self.failUnlessEqual(os.path.getsize(fn),0)

    Draw.MolToFile(self.mol,fn)

    self.failIfEqual(os.path.getsize(fn),0)
    try:
      os.unlink(fn)
    except:
      pass

def GetNeighborLists(probes,topN,pool,
                     simMetric=DataStructs.DiceSimilarity,
                     simThresh=-1.,
                     silent=False,
                     **kwargs):
  probeFps = [x[1] for x in probes]
  validProbes = [x for x in range(len(probeFps)) if probeFps[x] is not None]
  validFps=[probeFps[x] for x in validProbes]
  from rdkit.DataStructs.TopNContainer import TopNContainer
  if simThresh<=0:
    nbrLists = [TopNContainer(topN) for x in range(len(probeFps))]
  else:
    nbrLists=[TopNContainer(-1) for x in range(len(probeFps))]

  nDone=0
  for nm,fp in pool:
    nDone+=1
    if not silent and not nDone%1000: logger.info('  searched %d rows'%nDone)
    if(simMetric==DataStructs.DiceSimilarity):
      scores = DataStructs.BulkDiceSimilarity(fp,validFps)
      for i,score in enumerate(scores):
        if score>simThresh:
          nbrLists[validProbes[i]].Insert(score,nm)
    elif(simMetric==DataStructs.TanimotoSimilarity):
      scores = DataStructs.BulkTanimotoSimilarity(fp,validFps)
      for i,score in enumerate(scores):
        if score>simThresh:
          nbrLists[validProbes[i]].Insert(score,nm)
    elif(simMetric==DataStructs.TverskySimilarity):
      av = float(kwargs.get('tverskyA',0.5))
      bv = float(kwargs.get('tverskyB',0.5))
      scores = DataStructs.BulkTverskySimilarity(fp,validFps,av,bv)
      for i,score in enumerate(scores):
        if score>simThresh:
          nbrLists[validProbes[i]].Insert(score,nm)
    else:
      for i in range(len(probeFps)):
        pfp = probeFps[i]
        if pfp is not None:
          score = simMetric(probeFps[i],fp)
          if score>simThresh:
            nbrLists[validProbes[i]].Insert(score,nm)
  return nbrLists

def CreateDb(options,dataFilename='',supplier=None):
  if not dataFilename and supplier is None:
    raise ValueError('Please provide either a data filename or a supplier')

  if options.errFilename:
    errFile=open(os.path.join(options.outDir,options.errFilename),'w+')
  else:
    errFile=None

  if options.noExtras:
    options.doPairs=False
    options.doDescriptors=False
    options.doFingerprints=False
    options.doPharm2D=False
    options.doGobbi2D=False
    options.doLayered=False
    options.doMorganFps=False

  if options.loadMols:
    if supplier is None:
      if not options.molFormat:
        ext = os.path.splitext(dataFilename)[-1].lower()
        if ext=='.sdf':
          options.molFormat='sdf'
        elif ext in ('.smi','.smiles','.txt','.csv'):
          options.molFormat='smiles'
          if not options.delimiter:
            # guess the delimiter
            import csv
            sniffer = csv.Sniffer()
            dlct=sniffer.sniff(open(dataFilename,'r').read(2000))
            options.delimiter=dlct.delimiter
            if not options.silent:
              logger.info('Guessing that delimiter is %s. Use --delimiter argument if this is wrong.'%repr(options.delimiter))

        if not options.silent:
          logger.info('Guessing that mol format is %s. Use --molFormat argument if this is wrong.'%repr(options.molFormat))  
      if options.molFormat=='smiles':
        if options.delimiter=='\\t': options.delimiter='\t'
        supplier=Chem.SmilesMolSupplier(dataFilename,
                                        titleLine=options.titleLine,
                                        delimiter=options.delimiter,
                                        smilesColumn=options.smilesColumn,
                                        nameColumn=options.nameColumn
                                        )
      else:
        supplier = Chem.SDMolSupplier(dataFilename)
    if not options.silent: logger.info('Reading molecules and constructing molecular database.')
    Loader.LoadDb(supplier,os.path.join(options.outDir,options.molDbName),
                  errorsTo=errFile,regName=options.regName,nameCol=options.molIdName,
                  skipProps=options.skipProps,defaultVal=options.missingPropertyVal,
                  addComputedProps=options.addProps,uniqNames=True,
                  skipSmiles=options.skipSmiles,maxRowsCached=int(options.maxRowsCached),
                  silent=options.silent,nameProp=options.nameProp,
                  lazySupplier=int(options.maxRowsCached)>0,
                  startAnew=not options.updateDb
                  )

  if options.doPairs:
    pairConn = DbConnect(os.path.join(options.outDir,options.pairDbName))
    pairCurs = pairConn.GetCursor()
    try:
      pairCurs.execute('drop table %s'%(options.pairTableName))
    except:
      pass
    pairCurs.execute('create table %s (guid integer not null primary key,%s varchar not null unique,atompairfp blob,torsionfp blob)'%(options.pairTableName,
                                                                                                         options.molIdName))

  if options.doFingerprints or options.doPharm2D or options.doGobbi2D or options.doLayered:
    fpConn = DbConnect(os.path.join(options.outDir,options.fpDbName))
    fpCurs=fpConn.GetCursor()
    try:
      fpCurs.execute('drop table %s'%(options.fpTableName))
    except:
      pass
    try:
      fpCurs.execute('drop table %s'%(options.pharm2DTableName))
    except:
      pass
    try:
      fpCurs.execute('drop table %s'%(options.gobbi2DTableName))
    except:
      pass
    try:
      fpCurs.execute('drop table %s'%(options.layeredTableName))
    except:
      pass

    if options.doFingerprints:
      fpCurs.execute('create table %s (guid integer not null primary key,%s varchar not null unique,rdkfp blob)'%(options.fpTableName,
                                                                                     options.molIdName))
    if options.doLayered:
      layeredQs = ','.join('?'*LayeredOptions.nWords)
      colDefs=','.join(['Col_%d integer'%(x+1) for x in range(LayeredOptions.nWords)])
      fpCurs.execute('create table %s (guid integer not null primary key,%s varchar not null unique,%s)'%(options.layeredTableName,
                                                                             options.molIdName,
                                                                             colDefs))
      
    if options.doPharm2D:
      fpCurs.execute('create table %s (guid integer not null primary key,%s varchar not null unique,pharm2dfp blob)'%(options.pharm2DTableName,
#.........这里部分代码省略.........

from rdkit import Chem
from rdkit import RDConfig
import time,cPickle,sys,gzip
from rdkit.RDLogger import logger
logger = logger()

logger.info('reading smarts')
qs = []
smas = []
for line in file(RDConfig.RDDataDir+'/SmartsLib/RLewis_smarts.txt','r').readlines():
    if line[0] == '#':
        continue
    line = line.split(' ')
    p = Chem.MolFromSmarts(line[0])
    if not p:
        print >>sys.stderr,line[0]
        continue
    smas.append(line[0])
    qs.append(p)

logger.info('reading target counts')
refFps = cPickle.loads(gzip.open('fps.1000.counts.pkl.gz','rb').read())

fps = []   
logger.info('reading mols:')
ms = cPickle.loads(gzip.open('mols.1000.pkl.gz','rb').read())
t1 = time.time()
nFail=0
for i,m in enumerate(ms):
    fp = [0]*len(qs)
    for j,q in enumerate(qs):

from rdkit.Chem import AllChem
from rdkit.RDLogger import logger

logger = logger()

tests = [1] * 1001
if len(sys.argv) > 1:
    tests = [0] * 1001
    tests[1] = 1
    for x in sys.argv[1:]:
        x = int(x)
        tests[x] = 1
ts = []
mols = []
lines = gzip.open("../Data/znp.50k.smi.gz", "rb").readlines()
logger.info("mols from smiles")
nMols = 0
nBad = 0
t1 = time.time()
for line in lines:
    line = line.strip().split(" ")
    m = Chem.MolFromSmiles(line[0])
    if m:
        nMols += 1
        mols.append(m)
    else:
        nBad += 1

t2 = time.time()
logger.info("Results1: %.2f seconds, %d passed, %d failed" % (t2 - t1, nMols, nBad))
ts.append(t2 - t1)

# propField is the name of the property (from the SD file) you want to use
# as the "activity"
propField='chemical_shift_1'

# similarity threshold for a pair to be considered interesting.
# (i.e. pairs with a similiarity below this value will not be
# added to the output.
similarityThreshold=0.5

if __name__=='__main__':
    suppl = Chem.SDMolSupplier(sys.argv[1])
    outF = file(sys.argv[2],'w+')

    data=[]
    logger.info('reading molecules and generating fingeprints')
    for i,mol in enumerate(suppl):
        if not mol:
            continue
        smi = Chem.MolToSmiles(mol,True)
        nm = mol.GetProp(nameField)
        property = float(mol.GetProp(propField))
        fp = GetMolFingerprint(mol,maxPathLength)
        data.append((nm,smi,property,fp))
        
    logger.info('  got %d molecules'%len(data))

    logger.info('calculating pairs')
    pairs = []
    for i in range(len(data)):
        for j in range(i+1,len(data)):

#.........这里部分代码省略.........
  molsOut=False
  if options.sdfOut:
    molsOut=True
    if options.sdfOut=='-':
      sdfOut=sys.stdout
    else:
      sdfOut = file(options.sdfOut,'w+')
  else:
    sdfOut=None
  if options.smilesOut:
    molsOut=True
    if options.smilesOut=='-':
      smilesOut=sys.stdout
    else:
      smilesOut = file(options.smilesOut,'w+')
  else:
    smilesOut=None

  if queryFilename:
    try:
      tmpF = file(queryFilename,'r')
    except IOError:
      logger.error('could not open query file %s'%queryFilename)
      sys.exit(1)

    if options.molFormat=='smiles':
      func=GetMolsFromSmilesFile
    elif options.molFormat=='sdf':
      func=GetMolsFromSDFile

    if not options.silent:
      msg='Reading query molecules'
      if fpBuilder: msg+=' and generating fingerprints'
      logger.info(msg)
    probes=[]
    i=0
    nms=[]
    for nm,smi,mol in func(queryFilename,None,options.nameProp):
      i+=1
      nms.append(nm)
      if not mol:
        logger.error('query molecule %d could not be built'%(i))
        probes.append((None,None))
        continue
      if fpBuilder:
        probes.append((mol,fpBuilder(mol)))
      else:
        probes.append((mol,None))
      if not options.silent and not i%1000:
        logger.info("  done %d"%i)
  else:
    probes=None

  conn=None
  idName = options.molIdName
  ids=None
  names=None
  molDbName = os.path.join(options.dbDir,options.molDbName)
  molIdName = options.molIdName
  mConn = DbConnect(molDbName)
  cns = [(x.lower(),y) for x,y in mConn.GetColumnNamesAndTypes('molecules')]
  idCol,idTyp=cns[0]
  if options.propQuery or options.queryMol:
    conn = DbConnect(molDbName)
    curs = conn.GetCursor()
    if options.queryMol:

    TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)
    TYPE_CHECKER["floatlist"] = check_floatlist


parser = OptionParser("distance predict", version="%prog", option_class=MyOption)
parser.add_option("--maxPathLength", "--max", default=8, type=int, help="maximum length path for the fingerprint")
parser.add_option("--similarityThreshold", "--sim", default=[0.9], type="floatlist", help="threshold for similarity")
parser.add_option("--numNeighbors", "--num", "-n", "-k", default=50, type=int, help="number of neighbors to consider")
parser.add_option("--neighborsFile", "--nbrs", default="", help="name of an output file to hold the neighbor lists")
parser.add_option("--scan", default=False, action="store_true")

if __name__ == "__main__":
    options, args = parser.parse_args()
    outF = file(args[-1], "w+")

    logger.info("reading training molecules and generating fingerprints")
    suppl = Chem.SDMolSupplier(args[0])
    train = []
    for i, mol in enumerate(suppl):
        if not mol:
            continue
        smi = Chem.MolToSmiles(mol, True)
        nm = mol.GetProp(nameField)
        property = float(mol.GetProp(propField))
        fp = GetMolFingerprint(mol, options.maxPathLength)
        train.append((nm, smi, fp, property))
    logger.info("  got %d molecules" % len(train))

    if len(args) > 2:
        suppl = Chem.SDMolSupplier(args[1])
        haveTest = True

from rdkit.Chem import AllChem
from rdkit.Chem import Recap
from rdkit.RDLogger import logger
logger = logger()

tests=[1]*1001
if len(sys.argv)>1:
    tests=[0]*1001
    tests[1]=1
    for x in sys.argv[1:]:
        x = int(x)
        tests[x] = 1
ts = []
mols = []
lines = gzip.open('../Data/znp.50k.smi.gz','rb').readlines()
logger.info('mols from smiles')
nMols=0
nBad=0
t1=time.time()
for line in lines:
    line = line.strip().split(' ')
    m = Chem.MolFromSmiles(line[0])
    if m:
        nMols+=1
        mols.append(m)
    else:
        nBad += 1
        
t2=time.time()
logger.info('Results1: %.2f seconds, %d passed, %d failed'%(t2-t1,nMols,nBad))
ts.append(t2-t1)

def CreateDb(options, dataFilename="", supplier=None):
    if not dataFilename and supplier is None:
        raise ValueError, "Please provide either a data filename or a supplier"

    if options.errFilename:
        errFile = file(os.path.join(options.outDir, options.errFilename), "w+")
    else:
        errFile = None

    if options.noExtras:
        options.doPairs = False
        options.doDescriptors = False
        options.doFingerprints = False
        options.doPharm2D = False
        options.doGobbi2D = False
        options.doLayered = False
        options.doMorganFps = False

    if options.loadMols:
        if supplier is None:
            if not options.molFormat:
                ext = os.path.splitext(dataFilename)[-1].lower()
                if ext == ".sdf":
                    options.molFormat = "sdf"
                elif ext in (".smi", ".smiles", ".txt", ".csv"):
                    options.molFormat = "smiles"
                    if not options.delimiter:
                        # guess the delimiter
                        import csv

                        sniffer = csv.Sniffer()
                        dlct = sniffer.sniff(file(dataFilename, "r").read(2000))
                        options.delimiter = dlct.delimiter
                        if not options.silent:
                            logger.info(
                                "Guessing that delimiter is %s. Use --delimiter argument if this is wrong."
                                % repr(options.delimiter)
                            )

                if not options.silent:
                    logger.info(
                        "Guessing that mol format is %s. Use --molFormat argument if this is wrong."
                        % repr(options.molFormat)
                    )
            if options.molFormat == "smiles":
                if options.delimiter == "\\t":
                    options.delimiter = "\t"
                supplier = Chem.SmilesMolSupplier(
                    dataFilename,
                    titleLine=options.titleLine,
                    delimiter=options.delimiter,
                    smilesColumn=options.smilesColumn,
                    nameColumn=options.nameColumn,
                )
            else:
                supplier = Chem.SDMolSupplier(dataFilename)
        if not options.silent:
            logger.info("Reading molecules and constructing molecular database.")
        Loader.LoadDb(
            supplier,
            os.path.join(options.outDir, options.molDbName),
            errorsTo=errFile,
            regName=options.regName,
            nameCol=options.molIdName,
            skipProps=options.skipProps,
            defaultVal=options.missingPropertyVal,
            addComputedProps=options.addProps,
            uniqNames=True,
            skipSmiles=options.skipSmiles,
            maxRowsCached=int(options.maxRowsCached),
            silent=options.silent,
            nameProp=options.nameProp,
            lazySupplier=int(options.maxRowsCached) > 0,
        )
    if options.doPairs:
        pairConn = DbConnect(os.path.join(options.outDir, options.pairDbName))
        pairCurs = pairConn.GetCursor()
        try:
            pairCurs.execute("drop table %s" % (options.pairTableName))
        except:
            pass
        pairCurs.execute(
            "create table %s (guid integer not null primary key,%s varchar not null unique,atompairfp blob,torsionfp blob)"
            % (options.pairTableName, options.molIdName)
        )

    if options.doFingerprints or options.doPharm2D or options.doGobbi2D or options.doLayered:
        fpConn = DbConnect(os.path.join(options.outDir, options.fpDbName))
        fpCurs = fpConn.GetCursor()
        try:
            fpCurs.execute("drop table %s" % (options.fpTableName))
        except:
            pass
        try:
            fpCurs.execute("drop table %s" % (options.pharm2DTableName))
        except:
            pass
        try:
            fpCurs.execute("drop table %s" % (options.gobbi2DTableName))
        except:
#.........这里部分代码省略.........

parser.add_option('--maxPathLength','--max',default=8,type=int,
                  help='maximum length path for the fingerprint')
parser.add_option('--similarityThreshold','--sim',default=[0.9],type='floatlist',
                  help='threshold for similarity')
parser.add_option('--numNeighbors','--num','-n','-k',default=50,type=int,
                  help='number of neighbors to consider')
parser.add_option('--neighborsFile','--nbrs',default='',
                  help='name of an output file to hold the neighbor lists')
parser.add_option('--scan',default=False,action="store_true")


if __name__=='__main__':
    options,args = parser.parse_args()
    outF = file(args[-1],'w+')

    logger.info('reading training molecules and generating fingerprints')
    suppl = Chem.SDMolSupplier(args[0])
    train=[]
    for i,mol in enumerate(suppl):
        if not mol:
            continue
        smi = Chem.MolToSmiles(mol,True)
        nm = mol.GetProp(nameField)
        property = float(mol.GetProp(propField))
        fp = GetMolFingerprint(mol,options.maxPathLength)
        train.append((nm,smi,fp,property))
    logger.info('  got %d molecules'%len(train))

    if len(args)>2:
        suppl = Chem.SDMolSupplier(args[1])
        haveTest=True