Python cPickle.dumps函数代码示例

    def testPointPickles(self):
        pt = geom.Point3D(2.0,-3.0,1.0)
        pt2 = cPickle.loads(cPickle.dumps(pt))
        self.assertTrue(feq(pt.x,pt2.x,1e-6))
        self.assertTrue(feq(pt.y,pt2.y,1e-6))
        self.assertTrue(feq(pt.z,pt2.z,1e-6))

        pt = geom.Point2D(2.0,-4.0)
        pt2 = cPickle.loads(cPickle.dumps(pt))
        self.assertTrue(feq(pt.x,pt2.x,1e-6))
        self.assertTrue(feq(pt.y,pt2.y,1e-6))

 def testPkl2(self):
     """ further pickle tests """
     smis = self.bigSmiList
     for smi in smis:
         m = Chem.MolFromSmiles(smi)
         newM1 = cPickle.loads(cPickle.dumps(m))
         newM2 = cPickle.loads(cPickle.dumps(newM1))
         oldSmi = Chem.MolToSmiles(newM1)
         newSmi = Chem.MolToSmiles(newM2)
         assert newM1.GetNumAtoms() == m.GetNumAtoms(), "num atoms comparison failed"
         assert newM2.GetNumAtoms() == m.GetNumAtoms(), "num atoms comparison failed"
         assert oldSmi == newSmi, "string compare failed: %s != %s" % (oldSmi, newSmi)

  def test2CatStringPickle(self):
    self._fillCat(self.smiList2)

    # test non-binary pickle:
    cat2 = cPickle.loads(cPickle.dumps(self.fragCat))
    assert cat2.GetNumEntries()==21
    assert cat2.GetFPLength()==21
    self._testBits(cat2)

    # test binary pickle:
    cat2 = cPickle.loads(cPickle.dumps(self.fragCat,1))
    assert cat2.GetNumEntries()==21
    assert cat2.GetFPLength()==21
    self._testBits(cat2)

  def test3Pickle2(self):
    """

    """
    l=1<<21
    v1 = ds.IntSparseIntVect(l)
    self.assertRaises(IndexError,lambda:v1[l+1])
    v1[0]=1
    v1[2]=2
    v1[1<<12]=3
    self.assertTrue(v1==v1)

    v2=  cPickle.loads(cPickle.dumps(v1))
    self.assertTrue(v2==v1)
    
    v3=  ds.IntSparseIntVect(v2.ToBinary())
    self.assertTrue(v2==v3)
    self.assertTrue(v1==v3)

    #cPickle.dump(v1,file('isiv.pkl','wb+'))
    with open(
      os.path.join(RDConfig.RDBaseDir, 
                   'Code/DataStructs/Wrap/testData/isiv.pkl'),
      'r'
      ) as tf:
      buf = tf.read().replace('\r\n', '\n').encode('utf-8')
      tf.close()
    with io.BytesIO(buf) as f:
      v3 = cPickle.load(f)
      self.assertTrue(v3==v1)

  def test3Pickle2(self):
    """

    """
    l=1<<21
    v1 = ds.IntSparseIntVect(l)
    self.assertRaises(IndexError,lambda:v1[l+1])
    v1[0]=1
    v1[2]=2
    v1[1<<12]=3
    self.assertTrue(v1==v1)

    v2=  cPickle.loads(cPickle.dumps(v1))
    self.assertTrue(v2==v1)
    
    v3=  ds.IntSparseIntVect(v2.ToBinary())
    self.assertTrue(v2==v3)
    self.assertTrue(v1==v3)

    #cPickle.dump(v1,file('isiv.pkl','wb+'))
    with open(
      os.path.join(RDConfig.RDBaseDir, 
                   'Code/DataStructs/Wrap/testData/isiv.pkl'),
      'rb'
      ) as f:
      v3 = cPickle.load(f)
      self.assertTrue(v3==v1)

 def test4Serialize(self):
   with open(self.smiName, 'r') as smiF:
     smiLines = smiF.readlines()
   fparams = FragmentCatalog.FragCatParams(1, 6, self.fName)
   fcat = FragmentCatalog.FragCatalog(fparams)
   fgen = FragmentCatalog.FragCatGenerator()
   suppl = Chem.SmilesMolSupplier(self.smiName, " ", 0, 1, 0)
   smiles = []
   for mol in suppl:
     nent = fgen.AddFragsFromMol(mol, fcat)
     smiles.append(Chem.MolToSmiles(mol))
   self.assertEqual(fcat.GetNumEntries(), 21)
   self.assertEqual(fcat.GetFPLength(), 21)
   pkl = cPickle.dumps(fcat)
   fcat2 = cPickle.loads(pkl)
   self.assertEqual(fcat2.GetNumEntries(), 21)
   self.assertEqual(fcat2.GetFPLength(), 21)
   fpgen = FragmentCatalog.FragFPGenerator()
   for i in range(len(smiles)):
     smi = smiles[i]
     mol = Chem.MolFromSmiles(smi)
     fp1 = fpgen.GetFPForMol(mol, fcat)
     fp2 = fpgen.GetFPForMol(mol, fcat2)
     self.assertEqual(fp1.GetNumOnBits(), fp2.GetNumOnBits())
     obl1 = fp1.GetOnBits()
     obl2 = fp2.GetOnBits()
     self.assertEqual(tuple(obl1), tuple(obl2))

 def testPkl1(self):
     " testing single molecule pickle "
     m = Chem.MolFromSmiles("CCOC")
     outS = Chem.MolToSmiles(m)
     m2 = cPickle.loads(cPickle.dumps(m))
     outS2 = Chem.MolToSmiles(m2)
     assert outS == outS2, "bad pickle: %s != %s" % (outS, outS2)

    def testPickle(self):
      ffeat = ChemicalFeatures.FreeChemicalFeature("HBondDonor", "HBondDonor1", geom.Point3D(1.0, 2.0, 3.0),123)
      pkl = cPickle.dumps(ffeat)
      ffeat2 = cPickle.loads(pkl, encoding='bytes')
      self.assertTrue(ffeat2.GetId()==ffeat.GetId());      
      self.assertTrue(ffeat2.GetFamily()==ffeat.GetFamily())
      self.assertTrue(ffeat2.GetType()==ffeat.GetType())
      self.assertTrue(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))

      # Check that the old pickled versions have not been broken        
      inF = open(os.path.join(RDConfig.RDBaseDir,
                              'Code/ChemicalFeatures/Wrap/testData/feat.pkl'),'rb')
      ffeat2=cPickle.load(inF, encoding='bytes')
      # this version (1.0) does not have an id in the byte stream 
      self.assertTrue(ffeat2.GetFamily()==ffeat.GetFamily())
      self.assertTrue(ffeat2.GetType()==ffeat.GetType())
      self.assertTrue(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))
        
      # Test the new version also has the id and works as expected
      
      # uncomment the following to generate (overrwrite) new version of pickled
      # data file
      #cPickle.dump(ffeat,file(os.path.join(RDConfig.RDBaseDir, 'Code/ChemicalFeatures/Wrap/testData/featv2.pkl'),'wb+'))
      inF = open(os.path.join(RDConfig.RDBaseDir,
                              'Code/ChemicalFeatures/Wrap/testData/featv2.pkl'),'rb')
      ffeat2=cPickle.load(inF, encoding='bytes')
      self.assertTrue(ffeat2.GetId()==ffeat.GetId());
      self.assertTrue(ffeat2.GetFamily()==ffeat.GetFamily())
      self.assertTrue(ffeat2.GetType()==ffeat.GetType())
      self.assertTrue(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))

 def _testPkl10(self):
   " testing 5k molecule pickles "
   inLines = open('%s/NCI/first_5K.smi'%(RDConfig.RDDataDir),'r').readlines()
   smis = []
   for line in inLines:
     smis.append(line.split('\t')[0])
   for smi in smis:
     m = Chem.MolFromSmiles(smi)
     newM1 = cPickle.loads(cPickle.dumps(m))
     newSmi1 = Chem.MolToSmiles(newM1)
     newM2 = cPickle.loads(cPickle.dumps(newM1))
     newSmi2 = Chem.MolToSmiles(newM2)
     assert newM1.GetNumAtoms()==m.GetNumAtoms(),'num atoms comparison failed'
     assert newM2.GetNumAtoms()==m.GetNumAtoms(),'num atoms comparison failed'
     assert len(newSmi1)>0,'empty smi1'
     assert len(newSmi2)>0,'empty smi2'
     assert newSmi1==newSmi2,'string compare failed:\n%s\n\t!=\n%s\norig smiles:\n%s'%(newSmi1,newSmi2,smi)

  def test6PickleEquals(self):
    " testing pickled tree equals "
    self._readyTree()
    pkl = cPickle.dumps(self.baseTree)
    oTree = cPickle.loads(pkl)

    assert oTree == self.baseTree, 'Pickle inequality test failed'

    self.baseTree.PruneChild(self.baseTree.GetChildren()[0])
    assert oTree != self.baseTree, 'Pickle inequality test failed (bad Tree.__cmp__)'

  def test2ExplicitPickle(self):
    nbits = 10000
    bv1 = DataStructs.ExplicitBitVect(nbits)
    for i in range(1000):
      x = random.randrange(0, nbits)
      bv1.SetBit(x)

    pkl = pickle.dumps(bv1, 1)
    bv2 = pickle.loads(pkl)
    for i in range(nbits):
      assert bv1[i] == bv2[i]

 def test3Pickles(self):
   #outF = file('../testData/rvvs.pkl','wb+')
   with open(os.path.join(RDConfig.RDBaseDir,
                  'Code/DataStructs/Wrap/testData/rvvs.pkl'),
     'rb') as inF:
       v1 = ds.RealValueVect(30)
       for i in range(15):
           v1[2*i] = 1.3
       v2 = cPickle.loads(cPickle.dumps(v1))
       self.assertAlmostEqual(ds.ComputeL1Norm(v1, v2), 0)
       #cPickle.dump(v1,outF)
       v2=cPickle.load(inF, encoding='bytes')
       self.assertAlmostEqual(ds.ComputeL1Norm(v1, v2), 0)
       self.assertAlmostEqual(v1.GetTotalVal(), v2.GetTotalVal())
       self.failUnless(v2.GetTotalVal()!=0)

    def test4GridPickles(self):
        grd = geom.UniformGrid3D(10.0, 9.0, 8.0, 0.5)
        self.assertTrue(grd.GetNumX() == 20)
        self.assertTrue(grd.GetNumY() == 18)
        self.assertTrue(grd.GetNumZ() == 16)
        grd.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.5, 0.25)
        grd.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.5, 0.25)
        grd.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.5, 0.25)
        grd.SetSphereOccupancy(geom.Point3D(2.0, 2.0, 0.0), 1.5, 0.25)

        self.assertTrue(geom.TanimotoDistance(grd,grd)==0.0)

        grd2 = cPickle.loads(cPickle.dumps(grd))
        self.assertTrue(grd2.GetNumX() == 20)
        self.assertTrue(grd2.GetNumY() == 18)
        self.assertTrue(grd2.GetNumZ() == 16)
        self.assertTrue(geom.TanimotoDistance(grd,grd2)==0.0)

  def test12Pickles(self):
    rxn = rdChemReactions.ReactionFromSmarts('[C:1]1[O:2][N:3]1>>[C:1]1[O:2].[N:3]1')
    pkl = cPickle.dumps(rxn)
    rxn = cPickle.loads(pkl)
    mol = Chem.MolFromSmiles('C1ON1')
    products = rxn.RunReactants([mol])
    self.assertEqual(len(products),1)
    for p in products:
      self.assertEqual(len(p),1)
      self.assertEqual(p[0].GetNumAtoms(),3)
      self.assertEqual(p[0].GetNumBonds(),2)

    rxn = rdChemReactions.ChemicalReaction(rxn.ToBinary())
    products = rxn.RunReactants([mol])
    self.assertEqual(len(products),1)
    for p in products:
      self.assertEqual(len(p),1)
      self.assertEqual(p[0].GetNumAtoms(),3)
      self.assertEqual(p[0].GetNumBonds(),2)

  def test1(self):
    cat = MolCatalog.CreateMolCatalog()
    es = []
    for smi in ('C1CCC1OC', 'C1CCC1', 'C'):
      m = Chem.MolFromSmiles(smi)
      entry = MolCatalog.MolCatalogEntry()
      entry.SetMol(m)
      self.assertTrue(entry.GetMol())
      eSmi = Chem.MolToSmiles(entry.GetMol())
      self.assertTrue(eSmi == Chem.MolToSmiles(m))
      entry.SetDescription(smi)
      self.assertTrue(entry.GetDescription() == smi)
      es.append(entry)

    v = cat.AddEntry(es[0])
    self.assertTrue(v == 0)
    self.assertTrue(cat.GetNumEntries() == 1)

    v = cat.AddEntry(es[1])
    self.assertTrue(v == 1)
    self.assertTrue(cat.GetNumEntries() == 2)

    v = cat.AddEntry(es[2])
    self.assertTrue(v == 2)
    self.assertTrue(cat.GetNumEntries() == 3)

    cat.AddEdge(0, 1)
    cat.AddEdge(0, 2)
    cat.AddEdge(1, 2)

    d = cPickle.dumps(cat)
    es = None
    entry = None
    cat = None

    cat = cPickle.loads(d)
    self.assertTrue(cat.GetNumEntries() == 3)
    cat = None