Make bytestrings into str for shelve (#3644)

celery/worker/state.py

@@ -217,22 +217,22 @@ class Persistent(object):
     def _sync_with(self, d):
         self._revoked_tasks.purge()
         d.update({
-            b'__proto__': 3,
-            b'zrevoked': self.compress(self._dumps(self._revoked_tasks)),
-            b'clock': self.clock.forward() if self.clock else 0,
+            str('__proto__'): 3,
+            str('zrevoked'): self.compress(self._dumps(self._revoked_tasks)),
+            str('clock'): self.clock.forward() if self.clock else 0,
         })
         return d
 
     def _merge_clock(self, d):
         if self.clock:
-            d[b'clock'] = self.clock.adjust(d.get(b'clock') or 0)
+            d[str('clock')] = self.clock.adjust(d.get(str('clock')) or 0)
 
     def _merge_revoked(self, d):
         try:
-            self._merge_revoked_v3(d[b'zrevoked'])
+            self._merge_revoked_v3(d[str('zrevoked')])
         except KeyError:
             try:
-                self._merge_revoked_v2(d.pop(b'revoked'))
+                self._merge_revoked_v2(d.pop(str('revoked')))
             except KeyError:
                 pass
         # purge expired items at boot

t/unit/worker/test_state.py

@@ -106,7 +106,7 @@ class test_Persistent:
 
     def add_revoked(self, p, *ids):
         for id in ids:
-            p.db.setdefault(b'revoked', LimitedSet()).add(id)
+            p.db.setdefault(str('revoked'), LimitedSet()).add(id)
 
     def test_merge(self, p, data=['foo', 'bar', 'baz']):
         state.revoked.update(data)
@@ -117,26 +117,26 @@ class test_Persistent:
     def test_merge_dict(self, p):
         p.clock = Mock()
         p.clock.adjust.return_value = 626
-        d = {b'revoked': {b'abc': time()}, b'clock': 313}
+        d = {str('revoked'): {str('abc'): time()}, str('clock'): 313}
         p._merge_with(d)
         p.clock.adjust.assert_called_with(313)
-        assert d[b'clock'] == 626
-        assert b'abc' in state.revoked
+        assert d[str('clock')] == 626
+        assert str('abc') in state.revoked
 
     def test_sync_clock_and_purge(self, p):
         passthrough = Mock()
         passthrough.side_effect = lambda x: x
         with patch('celery.worker.state.revoked') as revoked:
-            d = {b'clock': 0}
+            d = {str('clock'): 0}
             p.clock = Mock()
             p.clock.forward.return_value = 627
             p._dumps = passthrough
             p.compress = passthrough
             p._sync_with(d)
             revoked.purge.assert_called_with()
-            assert d[b'clock'] == 627
-            assert b'revoked' not in d
-            assert d[b'zrevoked'] is revoked
+            assert d[str('clock')] == 627
+            assert str('revoked') not in d
+            assert d[str('zrevoked')] is revoked
 
     def test_sync(self, p,
                   data1=['foo', 'bar', 'baz'], data2=['baz', 'ini', 'koz']):
@@ -145,8 +145,8 @@ class test_Persistent:
             state.revoked.add(item)
         p.sync()
 
-        assert p.db[b'zrevoked']
-        pickled = p.decompress(p.db[b'zrevoked'])
+        assert p.db[str('zrevoked')]
+        pickled = p.decompress(p.db[str('zrevoked')])
         assert pickled
         saved = pickle.loads(pickled)
         for item in data2: