Py3k compat:

- Moar OIDS-must-be-bytes.

- Moar SERIALS-must-be-bytes.

- Moar list()'ing of dict items.

persistent/picklecache.py

@@ -21,7 +21,6 @@ from persistent.interfaces import GHOST
 from persistent.interfaces import IPickleCache
 from persistent.interfaces import STICKY
 from persistent.interfaces import OID_TYPE
-from persistent.interfaces import SERIAL_TYPE
 
 class RingNode(object):
     # 32 byte fixed size wrapper.
@@ -83,7 +82,7 @@ class PickleCache(object):
         """ See IPickleCache.
         """
         if not isinstance(oid, OID_TYPE):
-            raise ValueError('OID must be string: %s' % oid)
+            raise ValueError('OID must be %s: %s' % (OID_TYPE, oid))
         if oid in self.persistent_classes:
             del self.persistent_classes[oid]
         else:
@@ -205,7 +204,7 @@ class PickleCache(object):
     def invalidate(self, to_invalidate):
         """ See IPickleCache.
         """
-        if isinstance(to_invalidate, str):
+        if isinstance(to_invalidate, OID_TYPE):
             self._invalidate(to_invalidate)
         else:
             for oid in to_invalidate:

persistent/tests/test_picklecache.py

@@ -125,20 +125,21 @@ class PickleCacheTests(unittest.TestCase):
     def test___setitem___non_ghost(self):
         from persistent.interfaces import UPTODATE
         from persistent._compat import _b
+        KEY = _b('uptodate')
         cache = self._makeOne()
         uptodate = self._makePersist(state=UPTODATE)
 
-        cache[_b('uptodate')] = uptodate
+        cache[KEY] = uptodate
 
         self.assertEqual(len(cache), 1)
         items = list(cache.items())
         self.assertEqual(len(items), 1)
         self.assertEqual(_len(cache.klass_items()), 0)
-        self.assertEqual(items[0][0], 'uptodate')
+        self.assertEqual(items[0][0], KEY)
         self.assertEqual(cache.ringlen(), 1)
         self.failUnless(items[0][1] is uptodate)
-        self.failUnless(cache['uptodate'] is uptodate)
-        self.failUnless(cache.get('uptodate') is uptodate)
+        self.failUnless(cache[KEY] is uptodate)
+        self.failUnless(cache.get(KEY) is uptodate)
 
     def test___setitem___persistent_class(self):
         from persistent._compat import _b

persistent/tests/test_timestamp.py

@@ -147,9 +147,10 @@ class pyTimeStampTests(unittest.TestCase):
 
     def test_repr(self):
         from persistent.timestamp import _makeOctets
+        from persistent._compat import _native
         SERIAL = _makeOctets('\x01' * 8)
         ts = self._makeOne(SERIAL)
-        self.assertEqual(SERIAL, repr(ts))
+        self.assertEqual(repr(ts), _native(SERIAL))
 
 class TimeStampTests(unittest.TestCase):
 

persistent/tests/test_wref.py

@@ -24,19 +24,21 @@ class WeakRefTests(unittest.TestCase):
         return self._getTargetClass()(ob)
 
     def test_ctor_target_wo_jar(self):
+        from persistent._compat import _b
         target = _makeTarget()
         wref = self._makeOne(target)
         self.assertTrue(wref._v_ob is target)
-        self.assertEqual(wref.oid, 'OID')
+        self.assertEqual(wref.oid, _b('OID'))
         self.assertTrue(wref.dm is None)
         self.assertFalse('database_name' in wref.__dict__)
 
     def test_ctor_target_w_jar(self):
+        from persistent._compat import _b
         target = _makeTarget()
         target._p_jar = jar = _makeJar()
         wref = self._makeOne(target)
         self.assertTrue(wref._v_ob is target)
-        self.assertEqual(wref.oid, 'OID')
+        self.assertEqual(wref.oid, _b('OID'))
         self.assertTrue(wref.dm is jar)
         self.assertEqual(wref.database_name, 'testing')
 

persistent/wref.py

@@ -88,7 +88,7 @@ class PersistentWeakKeyDictionary(Persistent):
 
     def __getstate__(self):
         state = Persistent.__getstate__(self)
-        state['data'] = state['data'].items()
+        state['data'] = list(state['data'].items())
         return state
 
     def __setstate__(self, state):