Adds pipelines

Author: itamarhaber

README.md

@@ -18,7 +18,7 @@ $ pip install rejson-py
 ```python
 from rejson import ReJSONClient, Path
 
-rj = ReJSONClient(host='localhost', port=6379)
+rj = Client(host='localhost', port=6379)
 
 # Set the key `obj` to some object
 obj = {

rejson/__init__.py

@@ -2,5 +2,5 @@
 `rejson-py is a client for ReJSON
 """
 
-from .client import ReJSONClient
+from .client import Client
 from .path import Path

rejson/client.py

@@ -38,7 +38,7 @@ def bulk_of_jsons(b):
             b[index] = json.loads(item)
     return b
 
-class ReJSONClient(StrictRedis):
+class Client(StrictRedis):
     """
     Implementation of ReJSON commands
 
@@ -70,7 +70,7 @@ class ReJSONClient(StrictRedis):
     }
 
     def __init__(self, *args, **kwargs):
-        super(ReJSONClient, self).__init__(*args, **kwargs)
+        super(Client, self).__init__(*args, **kwargs)
         self.__checkPrerequirements()
         # Set the module commands' callbacks
         for k, v in self.MODULE_CALLBACKS.iteritems():
@@ -237,3 +237,21 @@ def JSONObjLen(self, name, path=Path.rootPath()):
         ``name``
         """
         return self.execute_command('JSON.OBJLEN', name, str_path(path))
+
+    def pipeline(self, transaction=True, shard_hint=None):
+        """
+        Return a new pipeline object that can queue multiple commands for
+        later execution. ``transaction`` indicates whether all commands
+        should be executed atomically. Apart from making a group of operations
+        atomic, pipelines are useful for reducing the back-and-forth overhead
+        between the client and server.
+        """
+        return Pipeline(
+            self.connection_pool,
+            self.response_callbacks,
+            transaction,
+            shard_hint)
+
+class Pipeline(BasePipeline, Client):
+    "Pipeline for ReJSONClient"
+    pass

test/test.py

@@ -1,11 +1,11 @@
 import redis
 from unittest import TestCase
-from rejson import ReJSONClient, Path
+from rejson import Client, Path
 
 class ReJSONTestCase(TestCase):
     def testJSONSetGetDelShouldSucceed(self):
         "Test basic JSONSet/Get/Del"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         self.assertTrue(rj.JSONSet('foo', Path.rootPath(), 'bar'))
@@ -15,7 +15,7 @@ def testJSONSetGetDelShouldSucceed(self):
 
     def testMGetShouldSucceed(self):
         "Test JSONMGet"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('1', Path.rootPath(), 1)
@@ -26,15 +26,15 @@ def testMGetShouldSucceed(self):
 
     def testTypeShouldSucceed(self):
         "Test JSONType"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('1', Path.rootPath(), 1)
         self.assertEqual('integer', rj.JSONType('1'))
 
     def testNumIncrByShouldSucceed(self):
         "Test JSONNumIncrBy"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('num', Path.rootPath(), 1)
@@ -44,7 +44,7 @@ def testNumIncrByShouldSucceed(self):
 
     def testNumMultByShouldSucceed(self):
         "Test JSONNumIncrBy"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('num', Path.rootPath(), 1)
@@ -54,7 +54,7 @@ def testNumMultByShouldSucceed(self):
 
     def testStrAppendShouldSucceed(self):
         "Test JSONStrAppend"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('str', Path.rootPath(), 'foo')
@@ -63,7 +63,7 @@ def testStrAppendShouldSucceed(self):
 
     def testStrLenShouldSucceed(self):
         "Test JSONStrLen"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('str', Path.rootPath(), 'foo')
@@ -73,15 +73,15 @@ def testStrLenShouldSucceed(self):
 
     def testArrAppendShouldSucceed(self):
         "Test JSONSArrAppend"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('arr', Path.rootPath(), [1])
         self.assertEqual(2, rj.JSONArrAppend('arr', Path.rootPath(), 2))
 
     def testArrIndexShouldSucceed(self):
         "Test JSONSArrIndex"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('arr', Path.rootPath(), [0, 1, 2, 3, 4])
@@ -90,7 +90,7 @@ def testArrIndexShouldSucceed(self):
 
     def testArrInsertShouldSucceed(self):
         "Test JSONSArrInsert"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('arr', Path.rootPath(), [0, 4])
@@ -99,15 +99,15 @@ def testArrInsertShouldSucceed(self):
 
     def testArrLenShouldSucceed(self):
         "Test JSONSArrLen"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('arr', Path.rootPath(), [0, 1, 2, 3, 4])
         self.assertEqual(5, rj.JSONArrLen('arr', Path.rootPath()))
 
     def testArrPopShouldSucceed(self):
         "Test JSONSArrPop"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('arr', Path.rootPath(), [0, 1, 2, 3, 4])
@@ -119,7 +119,7 @@ def testArrPopShouldSucceed(self):
 
     def testArrTrimShouldSucceed(self):
         "Test JSONSArrPop"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         rj.JSONSet('arr', Path.rootPath(), [0, 1, 2, 3, 4])
@@ -128,7 +128,7 @@ def testArrTrimShouldSucceed(self):
 
     def testObjKeysShouldSucceed(self):
         "Test JSONSObjKeys"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         obj = { 'foo': 'bar', 'baz': 'qaz' }
@@ -141,18 +141,30 @@ def testObjKeysShouldSucceed(self):
 
     def testObjLenShouldSucceed(self):
         "Test JSONSObjLen"
-        rj = ReJSONClient()
+        rj = Client()
         rj.flushdb()
 
         obj = { 'foo': 'bar', 'baz': 'qaz' }
         rj.JSONSet('obj', Path.rootPath(), obj)
         self.assertEqual(len(obj), rj.JSONObjLen('obj', Path.rootPath()))
 
+    def testPipeline(self):
+        "Test pipeline"
+        rj = Client()
+        rj.flushdb()
+
+        p = rj.pipeline()
+        p.JSONSet('foo', Path.rootPath(), 'bar')
+        p.JSONGet('foo')
+        p.JSONDel('foo')
+        p.exists('foo')
+        self.assertListEqual([ True, 'bar', 1, False], p.execute())
+
     def testUsageExampleShouldSucceed(self):
         "Test the usage example"
 
         # Create a new rejson-py client
-        rj = ReJSONClient(host='localhost', port=6379)
+        rj = Client(host='localhost', port=6379)
 
         # Set the key `obj` to some object
         obj = {