Make it possible to dump to byte streams

Author: p

README.rst

@@ -187,14 +187,23 @@ Unicode
 -------
 
 Redis operates on bytes and has no concept of Unicode or encodings.
-JSON operates on Unicode strings and cannot serialize binary data. Therefore,
+JSON operates on (Unicode) strings and cannot serialize binary data. Therefore,
 redis-dump-load has to encode Unicode strings into byte strings when
 loading data into Redis and decode byte strings into Unicode strings
 when dumping data from Redis.
-By default redis-dump-load uses utf-8 for encoding and decoding.
+By default redis-dump-load uses utf-8 for encoding data sent to Redis
+and decoding data received from Redis.
 This behavior matches redis-py, whose default encoding is utf-8.
 A different encoding can be specified.
 
+``dumps`` returns strings, that is, instances of ``str`` on Python 2
+and instances of ``unicode`` on Python 3.
+
+When dumping to an IO object using ``dump``, and the IO object accepts
+byte strings (such as when a file is opened in binary mode),
+redis-dump-load will ``.encode()`` the dumped data using the default
+encoding in effect.
+
 ijson's yajl2 backend can only decode ``bytes`` instances, not ``str``.
 When loading data from a file opened in text mode and using ijson-yajl2,
 redis-dump-load will encode the file data using utf-8 encoding before

redisdl.py

@@ -138,8 +138,21 @@ def dumps(host='localhost', port=6379, password=None, db=0, pretty=False,
             subd['expireat'] = _time.time() + ttl
     return encoder.encode(table)
 
+class BytesWriteWrapper(object):
+    def __init__(self, stream):
+        self.stream = stream
+        
+    def write(self, str):
+        return self.stream.write(str.encode())
+
 def dump(fp, host='localhost', port=6379, password=None, db=0, pretty=False,
          unix_socket_path=None, encoding='utf-8', keys='*'):
+    
+    try:
+        fp.write('')
+    except TypeError:
+        fp = BytesWriteWrapper(fp)
+    
     if pretty:
         # hack to avoid implementing pretty printing
         fp.write(dumps(host=host, port=port, password=password, db=db,
@@ -356,14 +369,14 @@ def ijson_top_level_items(file, local_streaming_backend):
     except StopIteration:
         pass
 
-class TextWrapper(object):
+class TextReadWrapper(object):
     def __init__(self, fp):
         self.fp = fp
 
     def read(self, *args, **kwargs):
         return self.fp.read(*args, **kwargs).decode()
 
-class BytesWrapper(object):
+class BytesReadWrapper(object):
     def __init__(self, fp):
         self.fp = fp
 
@@ -394,15 +407,15 @@ def create_loader(fp, streaming_backend=None):
         if not have_ijson:
             raise TypeError('%s backend requested but ijson is not present' % streaming_backend)
         if py3 and isinstance(fp.read(0), str):
-            fp = BytesWrapper(fp)
+            fp = BytesReadWrapper(fp)
         def loader():
             return ijson_top_level_items(fp, option)
     else:
         if not have_jsaone:
             raise TypeError('jsaone backend requested but jsaone is not present')
         if py3 and isinstance(fp.read(0), bytes):
             # jsaone can only process text string data (str), not bytes
-            fp = TextWrapper(fp)
+            fp = TextReadWrapper(fp)
         def loader():
             return jsaone_mod.load(fp)
 

tests/module_test.py

@@ -279,3 +279,21 @@ def test_load_expireat_preference(self):
         redisdl.loads(dump, use_expireat=True)
         ttl = self.r.ttl('key')
         self.assertGreater(ttl, 36000)
+
+    def test_dump_to_stringio(self):
+        self.r.set('a', 'aaa')
+
+        fp = StringIO()
+        redisdl.dump(fp, keys='a')
+        actual = json.loads(fp.getvalue())
+
+        self.assertEqual(actual['a']['value'], 'aaa')
+
+    def test_dump_to_bytesio(self):
+        self.r.set('a', 'aaa')
+
+        fp = BytesIO()
+        redisdl.dump(fp, keys='a')
+        actual = json.loads(fp.getvalue().decode())
+
+        self.assertEqual(actual['a']['value'], 'aaa')