Initial commit.

Author: itamarhaber

.gitignore

@@ -0,0 +1,10 @@
+*
+!/**/
+!.gitignore
+!requirements.txt
+!**/*.py
+!**/*.md
+
+.env
+
+*.pyc

README.md

@@ -0,0 +1,42 @@
+# ReJSON Python Client
+
+This is a package that allows storing, updating and querying objects as JSON
+documents in a [Redis](https://redis.io) database that is extended with the
+[ReJSON module](https://github.com/redislabsmodules/rejson). The package extends
+[redis-py](https://github.com/andymccurdy/redis-py)'s interface with ReJSON's
+API, and performs on-the-fly serialization/deserialization of objects to/from
+JSON.
+
+## Installation
+
+```bash
+$ pip install rejson-py
+```
+
+## Usage example
+
+```python
+from rejson import Client, Path
+
+rj = Client(host='localhost', port=6379)
+
+# Set the key `obj` to some object
+rj.JSONSet('obj', Path.rootPath(), {
+    'answer': 42,
+    'arr': [None, True, 3.14],
+    'truth': {
+        'coord': 'out there'
+    }
+})
+
+# Get something
+question = 'Is there anybody... {}?'.format(
+    rj.JSONGet('obj', Path('.truth.coord'))
+)
+
+# Delete something (or perhaps nothing)
+rj.JSONDel('obj', Path('.arr[0]'))
+
+# Update something
+rj.JSONSet('obj', Path('.answer'), 2.17)
+```

rejson/__init__.py

@@ -0,0 +1,6 @@
+"""
+`rejson-py is a client for ReJSON
+"""
+
+from .client import Client
+from .path import Path

rejson/client.py

@@ -0,0 +1,122 @@
+from sys import stdout
+import json
+from redis import StrictRedis, exceptions
+from redis._compat import (b, basestring, bytes, imap, iteritems, iterkeys,
+                           itervalues, izip, long, nativestr, unicode,
+                           safe_unicode)
+from .path import Path
+
+def str_path(p):
+    "Returns the string representation of a path if it is of class Path"
+    if isinstance(p, Path):
+        return p.strPath
+    else:
+        return p
+
+def bulk_of_jsons(b):
+    "Replace serialized JSON values with objects in a bulk array response (list)"
+    for index, item in enumerate(b):
+        if item is not None:
+            b[index] = json.loads(item)
+    return b
+
+class Client(StrictRedis):
+    """
+    Implementation of ReJSON commands
+
+    This class provides an interface for ReJSON's commands and performs on-the-fly
+    serialization/deserialization of objects to/from JSON.
+    """
+
+    MODULE_INFO = {
+        'name': 'ReJSON',
+        'ver':  1
+    }
+
+    MODULE_CALLBACKS = {
+            'JSON.DEL': lambda r: int(r),
+            'JSON.GET': lambda r: json.loads(r),
+            'JSON.MGET': bulk_of_jsons,
+            'JSON.SET': lambda r: r and nativestr(r) == 'OK',
+    }
+
+    def __init__(self, **kwargs):
+        super(Client, self).__init__(**kwargs)
+        
+        self.__checkPrerequirements()
+        
+        # Inject the callbacks for the module's commands
+        self.response_callbacks.update(self.MODULE_CALLBACKS)
+
+    def __checkPrerequirements(self):
+        "Checks that the module is ready"
+        try:
+            reply = self.execute_command('MODULE', 'LIST')
+        except exceptions.ResponseError as e:
+            if e.message.startswith('unknown command'):
+                raise exceptions.RedisError('Modules are not supported '
+                                            'on your Redis server - consider '
+                                            'upgrading to a newer version.')
+        finally:
+            info = self.MODULE_INFO
+            for r in reply:
+                module = dict(zip(r[0::2], r[1::2]))
+                if info['name'] == module['name'] and \
+                    info['ver'] <= module['ver']:
+                    return
+            raise exceptions.RedisError('ReJSON is not loaded - follow the '
+                                        'instructions at http://rejson.io')
+
+    def JSONDel(self, name, path=Path.rootPath()):
+        """
+        Deletes the JSON value stored at key ``name`` under ``path``
+        """
+        return self.execute_command('JSON.DEL', name, str_path(path))
+
+    def JSONGet(self, name, *args):
+        """
+        Get the object stored as a JSON value at key ``name``
+        ``args`` is zero or more paths, and defaults to root path
+        """
+        pieces = [name]
+        if len(args) == 0:
+            pieces.append(Path.rootPath())
+        else:
+            for p in args:
+                    pieces.append(str_path(p))
+        return self.execute_command('JSON.GET', *pieces)
+
+    def JSONMGet(self, path, *args):
+        """
+        Gets the objects stored as a JSON values under ``path`` from 
+        keys ``args``
+        """
+        pieces = []
+        pieces.extend(args)
+        pieces.append(str_path(path))
+        return self.execute_command('JSON.MGET', *pieces)
+
+    def JSONSet(self, name, path, obj, nx=False, xx=False):
+        """
+        Set the JSON value at key ``name`` under the ``path`` to ``obj``
+        ``nx`` if set to True, set ``value`` only if it does not exist
+        ``xx`` if set to True, set ``value`` only if it exists
+        """
+        pieces = [name, str_path(path), json.dumps(obj)]
+
+        # Handle existential modifiers
+        if nx and xx:
+            raise Exception('nx and xx are mutually exclusive: use one, the '
+                            'other or neither - but not both')
+        elif nx:
+            pieces.append('NX')
+        elif xx:
+            pieces.append('XX')
+
+        return self.execute_command('JSON.SET', *pieces)
+
+    def JSONType(self, name, path=Path.rootPath()):
+        """
+        Gets the type of the JSON value under ``path`` from key ``name``
+        """
+        return self.execute_command('JSON.TYPE', name, str_path(path))

rejson/path.py

@@ -0,0 +1,9 @@
+class Path(object):
+    strPath = ''
+
+    @staticmethod
+    def rootPath():
+        return '.'
+
+    def __init__(self, path):
+        self.strPath = path

requirements.txt

@@ -0,0 +1,2 @@
+hiredis==0.2.0
+redis==2.10.5

setup.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+from setuptools import setup, find_packages
+
+setup(
+    name='rejson',
+    version='0.1',
+
+    description='ReJSON Python Client',
+    url='http://github.com/RedisLabs/rejson-py',
+    packages=find_packages(),
+    install_requires=['redis', 'hiredis', 'rmtest'],
+    classifiers=[
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: BSD License',
+        'Programming Language :: Python :: 2.7',
+        'Topic :: Database',
+        'Topic :: Software Development :: Testing'
+    ]
+)

test/test.py

@@ -0,0 +1,63 @@
+import redis
+from unittest import TestCase
+from rejson import Client, Path
+
+class ReJSONTestCase(TestCase):
+    
+    def testJSONSetGetDelShouldSucceed(self):
+        "Test basic JSONSet/Get/Del"
+        rj = Client()
+        rj.flushdb()
+
+        self.assertTrue(rj.JSONSet('foo', Path.rootPath(), 'bar'))
+        self.assertEqual('bar', rj.JSONGet('foo'))
+        self.assertEqual(1, rj.JSONDel('foo'))
+        self.assertFalse(rj.exists('foo'))
+
+    def testMGetShouldSucceed(self):
+        "Test JSONMGet"
+        rj = Client()
+        rj.flushdb()
+
+        rj.JSONSet('1', Path.rootPath(), 1)
+        rj.JSONSet('2', Path.rootPath(), 2)
+        r = rj.JSONMGet(Path.rootPath(), '1', '2')
+        e = [1, 2]
+        self.assertListEqual(e, r)
+
+    def testTypeShouldSucceed(self):
+        "Test JSONType"
+        rj = Client()
+        rj.flushdb()
+
+        rj.JSONSet('1', Path.rootPath(), 1)
+        self.assertEqual('integer', rj.JSONType('1'))
+
+    def testUsageExampleShouldSucceed(self):
+        "Test the usage example"
+
+        # Create a new rejson-py client
+        rj = Client(host='localhost', port=6379)
+
+        # Set the key `obj` to some object
+        rj.JSONSet('obj', Path.rootPath(), {
+            'answer': 42,
+            'arr': [None, True, 3.14],
+            'truth': {
+                'coord': 'out there'
+            }
+        })
+
+        # Get something
+        question = 'Is there anybody... {}?'.format(
+            rj.JSONGet('obj', Path('.truth.coord'))
+        )
+
+        # Delete something (or perhaps nothing)
+        rj.JSONDel('obj', Path('.arr[0]'))
+
+        # Update something
+        rj.JSONSet('obj', Path('.answer'), 2.17)
+
+if __name__ == '__main__':
+    unittest.main()