Python lib updated

[redis.git] / client-libraries / python / redis.py

diff --git a/client-libraries/python/redis.py b/client-libraries/python/redis.py
index 954c2769098bf3c999152756e1bf6e2435d7c8c6..9618901ea7227a00682bc0f07fa070502cabbe01 100644 (file)
--- a/client-libraries/python/redis.py
+++ b/client-libraries/python/redis.py
@@ -1,7 +1,12 @@
-#!/usr/bin/python
+#!/usr/bin/env python

 
 """ redis.py - A client for the Redis daemon.
 
 
 """ redis.py - A client for the Redis daemon.
 

+History:
+
+        - 20090603 fix missing errno import, add sunion and sunionstore commands,
+          generalize shebang (Jochen Kupperschmidt)
+

 """
 
 __author__ = "Ludovico Magnocavallo <ludo\x40qix\x2eit>"
 """
 
 __author__ = "Ludovico Magnocavallo <ludo\x40qix\x2eit>"


@@ -16,6 +21,8 @@ __date__ = "$LastChangedDate: 2009-03-17 16:15:55 +0100 (Mar, 17 Mar 2009) $"[18
 
 
 import socket
 
 
 import socket

+import decimal
+import errno

 
 
 BUFSIZE = 4096
 
 
 BUFSIZE = 4096


@@ -32,17 +39,31 @@ class Redis(object):
     """The main Redis client.
     """
     
     """The main Redis client.
     """
     

-    def __init__(self, host=None, port=None, timeout=None):
+    def __init__(self, host=None, port=None, timeout=None, db=None, nodelay=None, charset='utf8', errors='strict'):

         self.host = host or 'localhost'
         self.port = port or 6379
         if timeout:
             socket.setdefaulttimeout(timeout)
         self.host = host or 'localhost'
         self.port = port or 6379
         if timeout:
             socket.setdefaulttimeout(timeout)

+        self.nodelay = nodelay
+        self.charset = charset
+        self.errors = errors

         self._sock = None
         self._fp = None
         self._sock = None
         self._fp = None

+        self.db = db

         
         

+    def _encode(self, s):
+        if isinstance(s, str):
+            return s
+        if isinstance(s, unicode):
+            try:
+                return s.encode(self.charset, self.errors)
+            except UnicodeEncodeError, e:
+                raise InvalidData("Error encoding unicode value '%s': %s" % (value.encode(self.charset, 'replace'), e))
+        return str(s)
+    

     def _write(self, s):
         """
     def _write(self, s):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.connect()
         >>> r._sock.close()
         >>> try:
         >>> r.connect()
         >>> r._sock.close()
         >>> try:


@@ -76,86 +97,96 @@ class Redis(object):
     
     def ping(self):
         """
     
     def ping(self):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.ping()
         'PONG'
         >>> 
         """
         self.connect()
         self._write('PING\r\n')
         >>> r.ping()
         'PONG'
         >>> 
         """
         self.connect()
         self._write('PING\r\n')

-        return self._get_simple_response()
+        return self.get_response()

     
     

-    def set(self, name, value, preserve=False):
+    def set(self, name, value, preserve=False, getset=False):

         """
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.set('a', 'pippo')
         'OK'
         >>> r.set('a', 'pippo')
         'OK'

-        >>> try:
-        ...     r.set('a', u'pippo \u3235')
-        ... except InvalidData, e:
-        ...     print e
-        Error encoding unicode value for key 'a': 'ascii' codec can't encode character u'\u3235' in position 15: ordinal not in range(128).
+        >>> r.set('a', u'pippo \u3235')
+        'OK'
+        >>> r.get('a')
+        u'pippo \u3235'

         >>> r.set('b', 105.2)
         'OK'
         >>> r.set('b', 'xxx', preserve=True)
         0
         >>> r.get('b')
         >>> r.set('b', 105.2)
         'OK'
         >>> r.set('b', 'xxx', preserve=True)
         0
         >>> r.get('b')

-        '105.2'
+        Decimal("105.2")

         >>> 
         """
         self.connect()
         # the following will raise an error for unicode values that can't be encoded to ascii
         # we could probably add an 'encoding' arg to init, but then what do we do with get()?
         # convert back to unicode? and what about ints, or pickled values?
         >>> 
         """
         self.connect()
         # the following will raise an error for unicode values that can't be encoded to ascii
         # we could probably add an 'encoding' arg to init, but then what do we do with get()?
         # convert back to unicode? and what about ints, or pickled values?

-        try:
-            value = value if isinstance(value, basestring) else str(value)
-            self._write('%s %s %s\r\n%s\r\n' % (
-                'SETNX' if preserve else 'SET', name, len(value), value
+        if getset: command = 'GETSET'
+        elif preserve: command = 'SETNX'
+        else: command = 'SET'
+        value = self._encode(value)
+        self._write('%s %s %s\r\n%s\r\n' % (
+                command, name, len(value), value

             ))
             ))

-        except UnicodeEncodeError, e:
-            raise InvalidData("Error encoding unicode value for key '%s': %s." % (name, e))
-        return self._get_numeric_response() if preserve else self._get_simple_response()
+        return self.get_response()

     
     def get(self, name):
         """
     
     def get(self, name):
         """

-        >>> r = Redis()
-        >>> r.set('a', 'pippo'), r.set('b', 15), r.set('c', '\\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n'), r.set('d', '\\r\\n')
+        >>> r = Redis(db=9)
+        >>> r.set('a', 'pippo'), r.set('b', 15), r.set('c', ' \\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n '), r.set('d', '\\r\\n')

         ('OK', 'OK', 'OK', 'OK')
         >>> r.get('a')
         ('OK', 'OK', 'OK', 'OK')
         >>> r.get('a')

-        'pippo'
+        u'pippo'

         >>> r.get('b')
         >>> r.get('b')

-        '15'
+        15

         >>> r.get('d')
         >>> r.get('d')

-        '\\r\\n'
+        u'\\r\\n'

         >>> r.get('b')
         >>> r.get('b')

-        '15'
+        15

         >>> r.get('c')
         >>> r.get('c')

-        '\\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n'
+        u' \\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n '

         >>> r.get('c')
         >>> r.get('c')

-        '\\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n'
+        u' \\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n '

         >>> r.get('ajhsd')
         >>> 
         """
         self.connect()
         self._write('GET %s\r\n' % name)
         >>> r.get('ajhsd')
         >>> 
         """
         self.connect()
         self._write('GET %s\r\n' % name)

-        return self._get_value()
+        return self.get_response()

     
     

+    def getset(self, name, value):
+        """
+        >>> r = Redis(db=9)
+        >>> r.set('a', 'pippo')
+        'OK'
+        >>> r.getset('a', 2)
+        u'pippo'
+        >>> 
+        """
+        return self.set(name, value, getset=True)
+        

     def mget(self, *args):
         """
     def mget(self, *args):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.set('a', 'pippo'), r.set('b', 15), r.set('c', '\\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n'), r.set('d', '\\r\\n')
         ('OK', 'OK', 'OK', 'OK')
         >>> r.mget('a', 'b', 'c', 'd')
         >>> r.set('a', 'pippo'), r.set('b', 15), r.set('c', '\\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n'), r.set('d', '\\r\\n')
         ('OK', 'OK', 'OK', 'OK')
         >>> r.mget('a', 'b', 'c', 'd')

-        ['pippo', '15', '\\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n', '\\r\\n']
+        [u'pippo', 15, u'\\r\\naaa\\nbbb\\r\\ncccc\\nddd\\r\\n', u'\\r\\n']

         >>> 
         """
         self.connect()
         self._write('MGET %s\r\n' % ' '.join(args))
         >>> 
         """
         self.connect()
         self._write('MGET %s\r\n' % ' '.join(args))

-        return self._get_multi_response()
+        return self.get_response()

     
     def incr(self, name, amount=1):
         """
     
     def incr(self, name, amount=1):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('a')
         1
         >>> r.incr('a')
         >>> r.delete('a')
         1
         >>> r.incr('a')


@@ -171,11 +202,11 @@ class Redis(object):
             self._write('INCR %s\r\n' % name)
         else:
             self._write('INCRBY %s %s\r\n' % (name, amount))
             self._write('INCR %s\r\n' % name)
         else:
             self._write('INCRBY %s %s\r\n' % (name, amount))

-        return self._get_numeric_response()
+        return self.get_response()

 
     def decr(self, name, amount=1):
         """
 
     def decr(self, name, amount=1):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> if r.get('a'):
         ...     r.delete('a')
         ... else:
         >>> if r.get('a'):
         ...     r.delete('a')
         ... else:


@@ -194,11 +225,11 @@ class Redis(object):
             self._write('DECR %s\r\n' % name)
         else:
             self._write('DECRBY %s %s\r\n' % (name, amount))
             self._write('DECR %s\r\n' % name)
         else:
             self._write('DECRBY %s %s\r\n' % (name, amount))

-        return self._get_numeric_response()
+        return self.get_response()

     
     def exists(self, name):
         """
     
     def exists(self, name):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.exists('dsjhfksjdhfkdsjfh')
         0
         >>> r.set('a', 'a')
         >>> r.exists('dsjhfksjdhfkdsjfh')
         0
         >>> r.set('a', 'a')


@@ -209,11 +240,11 @@ class Redis(object):
         """
         self.connect()
         self._write('EXISTS %s\r\n' % name)
         """
         self.connect()
         self._write('EXISTS %s\r\n' % name)

-        return self._get_numeric_response()
+        return self.get_response()

 
     def delete(self, name):
         """
 
     def delete(self, name):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('dsjhfksjdhfkdsjfh')
         0
         >>> r.set('a', 'a')
         >>> r.delete('dsjhfksjdhfkdsjfh')
         0
         >>> r.set('a', 'a')


@@ -228,29 +259,36 @@ class Redis(object):
         """
         self.connect()
         self._write('DEL %s\r\n' % name)
         """
         self.connect()
         self._write('DEL %s\r\n' % name)

-        return self._get_numeric_response()
+        return self.get_response()

 
 

-    def key_type(self, name):
+    def get_type(self, name):

         """
         """

-        Not yet implemented.
+        >>> r = Redis(db=9)
+        >>> r.set('a', 3)
+        'OK'
+        >>> r.get_type('a')
+        'string'
+        >>> r.get_type('zzz')
+        >>> 

         """
         self.connect()
         self._write('TYPE %s\r\n' % name)
         """
         self.connect()
         self._write('TYPE %s\r\n' % name)

-        return self._get_simple_response()
+        res = self.get_response()
+        return None if res == 'none' else res

     
     def keys(self, pattern):
         """
     
     def keys(self, pattern):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.flush()
         'OK'
         >>> r.set('a', 'a')
         'OK'
         >>> r.keys('a*')
         >>> r.flush()
         'OK'
         >>> r.set('a', 'a')
         'OK'
         >>> r.keys('a*')

-        ['a']
+        [u'a']

         >>> r.set('a2', 'a')
         'OK'
         >>> r.keys('a*')
         >>> r.set('a2', 'a')
         'OK'
         >>> r.keys('a*')

-        ['a', 'a2']
+        [u'a', u'a2']

         >>> r.delete('a2')
         1
         >>> r.keys('sjdfhskjh*')
         >>> r.delete('a2')
         1
         >>> r.keys('sjdfhskjh*')


@@ -259,11 +297,11 @@ class Redis(object):
         """
         self.connect()
         self._write('KEYS %s\r\n' % pattern)
         """
         self.connect()
         self._write('KEYS %s\r\n' % pattern)

-        return self._get_value().split()
+        return self.get_response().split()

     
     def randomkey(self):
         """
     
     def randomkey(self):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.set('a', 'a')
         'OK'
         >>> isinstance(r.randomkey(), str)
         >>> r.set('a', 'a')
         'OK'
         >>> isinstance(r.randomkey(), str)


@@ -273,18 +311,16 @@ class Redis(object):
         #raise NotImplementedError("Implemented but buggy, do not use.")
         self.connect()
         self._write('RANDOMKEY\r\n')
         #raise NotImplementedError("Implemented but buggy, do not use.")
         self.connect()
         self._write('RANDOMKEY\r\n')

-        data = self._read().strip()
-        self._check_for_error(data)
-        return data
+        return self.get_response()

     
     def rename(self, src, dst, preserve=False):
         """
     
     def rename(self, src, dst, preserve=False):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> try:
         ...     r.rename('a', 'a')
         ... except ResponseError, e:
         ...     print e
         >>> try:
         ...     r.rename('a', 'a')
         ... except ResponseError, e:
         ...     print e

-        src and dest key are the same
+        source and destination objects are the same

         >>> r.rename('a', 'b')
         'OK'
         >>> try:
         >>> r.rename('a', 'b')
         'OK'
         >>> try:


@@ -301,14 +337,57 @@ class Redis(object):
         self.connect()
         if preserve:
             self._write('RENAMENX %s %s\r\n' % (src, dst))
         self.connect()
         if preserve:
             self._write('RENAMENX %s %s\r\n' % (src, dst))

-            return self._get_numeric_response()
+            return self.get_response()

         else:
             self._write('RENAME %s %s\r\n' % (src, dst))
         else:
             self._write('RENAME %s %s\r\n' % (src, dst))

-            return self._get_simple_response().strip()
+            return self.get_response() #.strip()
+        
+    def dbsize(self):
+        """
+        >>> r = Redis(db=9)
+        >>> type(r.dbsize())
+        <type 'int'>
+        >>> 
+        """
+        self.connect()
+        self._write('DBSIZE\r\n')
+        return self.get_response()
+    
+    def ttl(self, name):
+        """
+        >>> r = Redis(db=9)
+        >>> r.ttl('a')
+        -1
+        >>> r.expire('a', 10)
+        1
+        >>> r.ttl('a')
+        10
+        >>> r.expire('a', 0)
+        0
+        >>> 
+        """
+        self.connect()
+        self._write('TTL %s\r\n' % name)
+        return self.get_response()
+    
+    def expire(self, name, time):
+        """
+        >>> r = Redis(db=9)
+        >>> r.set('a', 1)
+        'OK'
+        >>> r.expire('a', 1)
+        1
+        >>> r.expire('zzzzz', 1)
+        0
+        >>> 
+        """
+        self.connect()
+        self._write('EXPIRE %s %s\r\n' % (name, time))
+        return self.get_response()

     
     def push(self, name, value, tail=False):
         """
     
     def push(self, name, value, tail=False):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('l')
         1
         >>> r.push('l', 'a')
         >>> r.delete('l')
         1
         >>> r.push('l', 'a')


@@ -323,19 +402,15 @@ class Redis(object):
         >>> 
         """
         self.connect()
         >>> 
         """
         self.connect()

-        # same considerations on unicode as in set() apply here
-        try:
-            value = value if isinstance(value, basestring) else str(value)
-            self._write('%s %s %s\r\n%s\r\n' % (
-                'LPUSH' if tail else 'RPUSH', name, len(value), value
-            ))
-        except UnicodeEncodeError, e:
-            raise InvalidData("Error encoding unicode value for element in list '%s': %s." % (name, e))
-        return self._get_simple_response()
+        value = self._encode(value)
+        self._write('%s %s %s\r\n%s\r\n' % (
+            'LPUSH' if tail else 'RPUSH', name, len(value), value
+        ))
+        return self.get_response()

     
     def llen(self, name):
         """
     
     def llen(self, name):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('l')
         1
         >>> r.push('l', 'a')
         >>> r.delete('l')
         1
         >>> r.push('l', 'a')


@@ -350,11 +425,11 @@ class Redis(object):
         """
         self.connect()
         self._write('LLEN %s\r\n' % name)
         """
         self.connect()
         self._write('LLEN %s\r\n' % name)

-        return self._get_numeric_response()
+        return self.get_response()

 
     def lrange(self, name, start, end):
         """
 
     def lrange(self, name, start, end):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('l')
         1
         >>> r.lrange('l', 0, 1)
         >>> r.delete('l')
         1
         >>> r.lrange('l', 0, 1)


@@ -362,26 +437,26 @@ class Redis(object):
         >>> r.push('l', 'aaa')
         'OK'
         >>> r.lrange('l', 0, 1)
         >>> r.push('l', 'aaa')
         'OK'
         >>> r.lrange('l', 0, 1)

-        ['aaa']
+        [u'aaa']

         >>> r.push('l', 'bbb')
         'OK'
         >>> r.lrange('l', 0, 0)
         >>> r.push('l', 'bbb')
         'OK'
         >>> r.lrange('l', 0, 0)

-        ['aaa']
+        [u'aaa']

         >>> r.lrange('l', 0, 1)
         >>> r.lrange('l', 0, 1)

-        ['aaa', 'bbb']
+        [u'aaa', u'bbb']

         >>> r.lrange('l', -1, 0)
         []
         >>> r.lrange('l', -1, -1)
         >>> r.lrange('l', -1, 0)
         []
         >>> r.lrange('l', -1, -1)

-        ['bbb']
+        [u'bbb']

         >>> 
         """
         self.connect()
         self._write('LRANGE %s %s %s\r\n' % (name, start, end))
         >>> 
         """
         self.connect()
         self._write('LRANGE %s %s %s\r\n' % (name, start, end))

-        return self._get_multi_response()
+        return self.get_response()

         
     def ltrim(self, name, start, end):
         """
         
     def ltrim(self, name, start, end):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('l')
         1
         >>> try:
         >>> r.delete('l')
         1
         >>> try:


@@ -407,33 +482,33 @@ class Redis(object):
         """
         self.connect()
         self._write('LTRIM %s %s %s\r\n' % (name, start, end))
         """
         self.connect()
         self._write('LTRIM %s %s %s\r\n' % (name, start, end))

-        return self._get_simple_response()
+        return self.get_response()

     
     def lindex(self, name, index):
         """
     
     def lindex(self, name, index):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> res = r.delete('l')
         >>> r.lindex('l', 0)
         >>> r.push('l', 'aaa')
         'OK'
         >>> r.lindex('l', 0)
         >>> res = r.delete('l')
         >>> r.lindex('l', 0)
         >>> r.push('l', 'aaa')
         'OK'
         >>> r.lindex('l', 0)

-        'aaa'
+        u'aaa'

         >>> r.lindex('l', 2)
         >>> r.push('l', 'ccc')
         'OK'
         >>> r.lindex('l', 1)
         >>> r.lindex('l', 2)
         >>> r.push('l', 'ccc')
         'OK'
         >>> r.lindex('l', 1)

-        'ccc'
+        u'ccc'

         >>> r.lindex('l', -1)
         >>> r.lindex('l', -1)

-        'ccc'
+        u'ccc'

         >>> 
         """
         self.connect()
         self._write('LINDEX %s %s\r\n' % (name, index))
         >>> 
         """
         self.connect()
         self._write('LINDEX %s %s\r\n' % (name, index))

-        return self._get_value()
+        return self.get_response()

         
     def pop(self, name, tail=False):
         """
         
     def pop(self, name, tail=False):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('l')
         1
         >>> r.pop('l')
         >>> r.delete('l')
         1
         >>> r.pop('l')


@@ -442,28 +517,28 @@ class Redis(object):
         >>> r.push('l', 'bbb')
         'OK'
         >>> r.pop('l')
         >>> r.push('l', 'bbb')
         'OK'
         >>> r.pop('l')

-        'aaa'
+        u'aaa'

         >>> r.pop('l')
         >>> r.pop('l')

-        'bbb'
+        u'bbb'

         >>> r.pop('l')
         >>> r.push('l', 'aaa')
         'OK'
         >>> r.push('l', 'bbb')
         'OK'
         >>> r.pop('l', tail=True)
         >>> r.pop('l')
         >>> r.push('l', 'aaa')
         'OK'
         >>> r.push('l', 'bbb')
         'OK'
         >>> r.pop('l', tail=True)

-        'bbb'
+        u'bbb'

         >>> r.pop('l')
         >>> r.pop('l')

-        'aaa'
+        u'aaa'

         >>> r.pop('l')
         >>> 
         """
         self.connect()
         self._write('%s %s\r\n' % ('RPOP' if tail else 'LPOP', name))
         >>> r.pop('l')
         >>> 
         """
         self.connect()
         self._write('%s %s\r\n' % ('RPOP' if tail else 'LPOP', name))

-        return self._get_value()
+        return self.get_response()

     
     def lset(self, name, index, value):
         """
     
     def lset(self, name, index, value):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('l')
         1
         >>> try:
         >>> r.delete('l')
         1
         >>> try:


@@ -481,22 +556,19 @@ class Redis(object):
         >>> r.lset('l', 0, 'bbb')
         'OK'
         >>> r.lrange('l', 0, 1)
         >>> r.lset('l', 0, 'bbb')
         'OK'
         >>> r.lrange('l', 0, 1)

-        ['bbb']
+        [u'bbb']

         >>> 
         """
         self.connect()
         >>> 
         """
         self.connect()

-        try:
-            value = value if isinstance(value, basestring) else str(value)
-            self._write('LSET %s %s %s\r\n%s\r\n' % (
-                name, index, len(value), value
-            ))
-        except UnicodeEncodeError, e:
-            raise InvalidData("Error encoding unicode value for element %s in list '%s': %s." % (index, name, e))
-        return self._get_simple_response()
+        value = self._encode(value)
+        self._write('LSET %s %s %s\r\n%s\r\n' % (
+            name, index, len(value), value
+        ))
+        return self.get_response()

     
     def lrem(self, name, value, num=0):
         """
     
     def lrem(self, name, value, num=0):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('l')
         1
         >>> r.push('l', 'aaa')
         >>> r.delete('l')
         1
         >>> r.push('l', 'aaa')


@@ -508,7 +580,7 @@ class Redis(object):
         >>> r.lrem('l', 'aaa')
         2
         >>> r.lrange('l', 0, 10)
         >>> r.lrem('l', 'aaa')
         2
         >>> r.lrange('l', 0, 10)

-        ['bbb']
+        [u'bbb']

         >>> r.push('l', 'aaa')
         'OK'
         >>> r.push('l', 'aaa')
         >>> r.push('l', 'aaa')
         'OK'
         >>> r.push('l', 'aaa')


@@ -522,18 +594,15 @@ class Redis(object):
         >>> 
         """
         self.connect()
         >>> 
         """
         self.connect()

-        try:
-            value = value if isinstance(value, basestring) else str(value)
-            self._write('LREM %s %s %s\r\n%s\r\n' % (
-                name, num, len(value), value
-            ))
-        except UnicodeEncodeError, e:
-            raise InvalidData("Error encoding unicode value for element %s in list '%s': %s." % (index, name, e))
-        return self._get_numeric_response()
+        value = self._encode(value)
+        self._write('LREM %s %s %s\r\n%s\r\n' % (
+            name, num, len(value), value
+        ))
+        return self.get_response()

     
     def sort(self, name, by=None, get=None, start=None, num=None, desc=False, alpha=False):
         """
     
     def sort(self, name, by=None, get=None, start=None, num=None, desc=False, alpha=False):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('l')
         1
         >>> r.push('l', 'ccc')
         >>> r.delete('l')
         1
         >>> r.push('l', 'ccc')


@@ -545,27 +614,27 @@ class Redis(object):
         >>> r.push('l', 'bbb')
         'OK'
         >>> r.sort('l', alpha=True)
         >>> r.push('l', 'bbb')
         'OK'
         >>> r.sort('l', alpha=True)

-        ['aaa', 'bbb', 'ccc', 'ddd']
+        [u'aaa', u'bbb', u'ccc', u'ddd']

         >>> r.delete('l')
         1
         >>> for i in range(1, 5):
         ...     res = r.push('l', 1.0 / i)
         >>> r.sort('l')
         >>> r.delete('l')
         1
         >>> for i in range(1, 5):
         ...     res = r.push('l', 1.0 / i)
         >>> r.sort('l')

-        ['0.25', '0.333333333333', '0.5', '1.0']
+        [Decimal("0.25"), Decimal("0.333333333333"), Decimal("0.5"), Decimal("1.0")]

         >>> r.sort('l', desc=True)
         >>> r.sort('l', desc=True)

-        ['1.0', '0.5', '0.333333333333', '0.25']
+        [Decimal("1.0"), Decimal("0.5"), Decimal("0.333333333333"), Decimal("0.25")]

         >>> r.sort('l', desc=True, start=2, num=1)
         >>> r.sort('l', desc=True, start=2, num=1)

-        ['0.333333333333']
+        [Decimal("0.333333333333")]

         >>> r.set('weight_0.5', 10)
         'OK'
         >>> r.sort('l', desc=True, by='weight_*')
         >>> r.set('weight_0.5', 10)
         'OK'
         >>> r.sort('l', desc=True, by='weight_*')

-        ['0.5', '1.0', '0.333333333333', '0.25']
+        [Decimal("0.5"), Decimal("1.0"), Decimal("0.333333333333"), Decimal("0.25")]

         >>> for i in r.sort('l', desc=True):
         ...     res = r.set('test_%s' % i, 100 - float(i))
         >>> r.sort('l', desc=True, get='test_*')
         >>> for i in r.sort('l', desc=True):
         ...     res = r.set('test_%s' % i, 100 - float(i))
         >>> r.sort('l', desc=True, get='test_*')

-        ['99.0', '99.5', '99.6666666667', '99.75']
+        [Decimal("99.0"), Decimal("99.5"), Decimal("99.6666666667"), Decimal("99.75")]

         >>> r.sort('l', desc=True, by='weight_*', get='test_*')
         >>> r.sort('l', desc=True, by='weight_*', get='test_*')

-        ['99.5', '99.0', '99.6666666667', '99.75']
+        [Decimal("99.5"), Decimal("99.0"), Decimal("99.6666666667"), Decimal("99.75")]

         >>> r.sort('l', desc=True, by='weight_*', get='missing_*')
         [None, None, None, None]
         >>> 
         >>> r.sort('l', desc=True, by='weight_*', get='missing_*')
         [None, None, None, None]
         >>> 


@@ -590,11 +659,11 @@ class Redis(object):
             stmt.append("ALPHA")
         self.connect()
         self._write(' '.join(stmt + ["\r\n"]))
             stmt.append("ALPHA")
         self.connect()
         self._write(' '.join(stmt + ["\r\n"]))

-        return self._get_multi_response()
+        return self.get_response()

     
     def sadd(self, name, value):
         """
     
     def sadd(self, name, value):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> res = r.delete('s')
         >>> r.sadd('s', 'a')
         1
         >>> res = r.delete('s')
         >>> r.sadd('s', 'a')
         1


@@ -603,19 +672,15 @@ class Redis(object):
         >>> 
         """
         self.connect()
         >>> 
         """
         self.connect()

-        # same considerations on unicode as in set() apply here
-        try:
-            value = value if isinstance(value, basestring) else str(value)
-            self._write('SADD %s %s\r\n%s\r\n' % (
-                name, len(value), value
-            ))
-        except UnicodeEncodeError, e:
-            raise InvalidData("Error encoding unicode value for element in set '%s': %s." % (name, e))
-        return self._get_numeric_response()
+        value = self._encode(value)
+        self._write('SADD %s %s\r\n%s\r\n' % (
+            name, len(value), value
+        ))
+        return self.get_response()

         
     def srem(self, name, value):
         """
         
     def srem(self, name, value):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('s')
         1
         >>> r.srem('s', 'aaa')
         >>> r.delete('s')
         1
         >>> r.srem('s', 'aaa')


@@ -629,19 +694,15 @@ class Redis(object):
         >>> 
         """
         self.connect()
         >>> 
         """
         self.connect()

-        # same considerations on unicode as in set() apply here
-        try:
-            value = value if isinstance(value, basestring) else str(value)
-            self._write('SREM %s %s\r\n%s\r\n' % (
-                name, len(value), value
-            ))
-        except UnicodeEncodeError, e:
-            raise InvalidData("Error encoding unicode value for element in set '%s': %s." % (name, e))
-        return self._get_numeric_response()
+        value = self._encode(value)
+        self._write('SREM %s %s\r\n%s\r\n' % (
+            name, len(value), value
+        ))
+        return self.get_response()

     
     def sismember(self, name, value):
         """
     
     def sismember(self, name, value):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('s')
         1
         >>> r.sismember('s', 'b')
         >>> r.delete('s')
         1
         >>> r.sismember('s', 'b')


@@ -655,19 +716,15 @@ class Redis(object):
         >>>
         """
         self.connect()
         >>>
         """
         self.connect()

-        # same considerations on unicode as in set() apply here
-        try:
-            value = value if isinstance(value, basestring) else str(value)
-            self._write('SISMEMBER %s %s\r\n%s\r\n' % (
-                name, len(value), value
-            ))
-        except UnicodeEncodeError, e:
-            raise InvalidData("Error encoding unicode value for element in set '%s': %s." % (name, e))
-        return self._get_numeric_response()
+        value = self._encode(value)
+        self._write('SISMEMBER %s %s\r\n%s\r\n' % (
+            name, len(value), value
+        ))
+        return self.get_response()

     
     def sinter(self, *args):
         """
     
     def sinter(self, *args):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> res = r.delete('s1')
         >>> res = r.delete('s2')
         >>> res = r.delete('s3')
         >>> res = r.delete('s1')
         >>> res = r.delete('s2')
         >>> res = r.delete('s3')


@@ -690,16 +747,16 @@ class Redis(object):
         >>> r.sinter('s1', 's2', 's3')
         set([])
         >>> r.sinter('s1', 's2')
         >>> r.sinter('s1', 's2', 's3')
         set([])
         >>> r.sinter('s1', 's2')

-        set(['a'])
+        set([u'a'])

         >>> 
         """
         self.connect()
         self._write('SINTER %s\r\n' % ' '.join(args))
         >>> 
         """
         self.connect()
         self._write('SINTER %s\r\n' % ' '.join(args))

-        return set(self._get_multi_response())
+        return set(self.get_response())

     
     def sinterstore(self, dest, *args):
         """
     
     def sinterstore(self, dest, *args):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> res = r.delete('s1')
         >>> res = r.delete('s2')
         >>> res = r.delete('s3')
         >>> res = r.delete('s1')
         >>> res = r.delete('s2')
         >>> res = r.delete('s3')


@@ -710,20 +767,20 @@ class Redis(object):
         >>> r.sadd('s3', 'b')
         1
         >>> r.sinterstore('s_s', 's1', 's2', 's3')
         >>> r.sadd('s3', 'b')
         1
         >>> r.sinterstore('s_s', 's1', 's2', 's3')

-        'OK'
+        0

         >>> r.sinterstore('s_s', 's1', 's2')
         >>> r.sinterstore('s_s', 's1', 's2')

-        'OK'
+        1

         >>> r.smembers('s_s')
         >>> r.smembers('s_s')

-        set(['a'])
+        set([u'a'])

         >>> 
         """
         self.connect()
         self._write('SINTERSTORE %s %s\r\n' % (dest, ' '.join(args)))
         >>> 
         """
         self.connect()
         self._write('SINTERSTORE %s %s\r\n' % (dest, ' '.join(args)))

-        return self._get_simple_response()
+        return self.get_response()

 
     def smembers(self, name):
         """
 
     def smembers(self, name):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('s')
         1
         >>> r.sadd('s', 'a')
         >>> r.delete('s')
         1
         >>> r.sadd('s', 'a')


@@ -736,65 +793,109 @@ class Redis(object):
         ...     print e
         Operation against a key holding the wrong kind of value
         >>> r.smembers('s')
         ...     print e
         Operation against a key holding the wrong kind of value
         >>> r.smembers('s')

-        set(['a', 'b'])
+        set([u'a', u'b'])

         >>> 
         """
         self.connect()
         self._write('SMEMBERS %s\r\n' % name)
         >>> 
         """
         self.connect()
         self._write('SMEMBERS %s\r\n' % name)

-        return set(self._get_multi_response())
+        return set(self.get_response())
+
+    def sunion(self, *args):
+        """
+        >>> r = Redis(db=9)
+        >>> res = r.delete('s1')
+        >>> res = r.delete('s2')
+        >>> res = r.delete('s3')
+        >>> r.sadd('s1', 'a')
+        1
+        >>> r.sadd('s2', 'a')
+        1
+        >>> r.sadd('s3', 'b')
+        1
+        >>> r.sunion('s1', 's2', 's3')
+        set([u'a', u'b'])
+        >>> r.sadd('s2', 'c')
+        1
+        >>> r.sunion('s1', 's2', 's3')
+        set([u'a', u'c', u'b'])
+        >>> 
+        """
+        self.connect()
+        self._write('SUNION %s\r\n' % ' '.join(args))
+        return set(self.get_response())
+
+    def sunionstore(self, dest, *args):
+        """
+        >>> r = Redis(db=9)
+        >>> res = r.delete('s1')
+        >>> res = r.delete('s2')
+        >>> res = r.delete('s3')
+        >>> r.sadd('s1', 'a')
+        1
+        >>> r.sadd('s2', 'a')
+        1
+        >>> r.sadd('s3', 'b')
+        1
+        >>> r.sunionstore('s4', 's1', 's2', 's3')
+        2
+        >>> r.smembers('s4')
+        set([u'a', u'b'])
+        >>> 
+        """
+        self.connect()
+        self._write('SUNIONSTORE %s %s\r\n' % (dest, ' '.join(args)))
+        return self.get_response()

 
     def select(self, db):
         """
 
     def select(self, db):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.delete('a')
         1
         >>> r.delete('a')
         1

-        >>> r.select(1)
+        >>> r.select(10)

         'OK'
         >>> r.set('a', 1)
         'OK'
         'OK'
         >>> r.set('a', 1)
         'OK'

-        >>> r.select(0)
+        >>> r.select(9)

         'OK'
         >>> r.get('a')
         >>> 
         """
         self.connect()
         self._write('SELECT %s\r\n' % db)
         'OK'
         >>> r.get('a')
         >>> 
         """
         self.connect()
         self._write('SELECT %s\r\n' % db)

-        return self._get_simple_response()
+        return self.get_response()

     
     def move(self, name, db):
         """
     
     def move(self, name, db):
         """

-        >>> r = Redis()
-        >>> r.select(0)
-        'OK'
+        >>> r = Redis(db=9)

         >>> r.set('a', 'a')
         'OK'
         >>> r.set('a', 'a')
         'OK'

-        >>> r.select(1)
+        >>> r.select(10)

         'OK'
         >>> if r.get('a'):
         ...     r.delete('a')
         ... else:
         ...     print 1
         1
         'OK'
         >>> if r.get('a'):
         ...     r.delete('a')
         ... else:
         ...     print 1
         1

-        >>> r.select(0)
+        >>> r.select(9)

         'OK'
         'OK'

-        >>> r.move('a', 1)
+        >>> r.move('a', 10)

         1
         >>> r.get('a')
         1
         >>> r.get('a')

-        >>> r.select(1)
+        >>> r.select(10)

         'OK'
         >>> r.get('a')
         'OK'
         >>> r.get('a')

-        'a'
-        >>> r.select(0)
+        u'a'
+        >>> r.select(9)

         'OK'
         >>> 
         """
         self.connect()
         self._write('MOVE %s %s\r\n' % (name, db))
         'OK'
         >>> 
         """
         self.connect()
         self._write('MOVE %s %s\r\n' % (name, db))

-        return self._get_numeric_response()
+        return self.get_response()

     
     def save(self, background=False):
         """
     
     def save(self, background=False):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.save()
         'OK'
         >>> try:
         >>> r.save()
         'OK'
         >>> try:


@@ -810,12 +911,12 @@ class Redis(object):
             self._write('BGSAVE\r\n')
         else:
             self._write('SAVE\r\n')
             self._write('BGSAVE\r\n')
         else:
             self._write('SAVE\r\n')

-        return self._get_simple_response()
+        return self.get_response()

         
     def lastsave(self):
         """
         >>> import time
         
     def lastsave(self):
         """
         >>> import time

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> t = int(time.time())
         >>> r.save()
         'OK'
         >>> t = int(time.time())
         >>> r.save()
         'OK'


@@ -825,24 +926,23 @@ class Redis(object):
         """
         self.connect()
         self._write('LASTSAVE\r\n')
         """
         self.connect()
         self._write('LASTSAVE\r\n')

-        return self._get_numeric_response()
+        return self.get_response()

     
     def flush(self, all_dbs=False):
         """
     
     def flush(self, all_dbs=False):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.flush()
         'OK'
         >>> r.flush()
         'OK'

-        >>> r.flush(all_dbs=True)
-        'OK'
+        >>> # r.flush(all_dbs=True)

         >>> 
         """
         self.connect()
         self._write('%s\r\n' % ('FLUSHALL' if all_dbs else 'FLUSHDB'))
         >>> 
         """
         self.connect()
         self._write('%s\r\n' % ('FLUSHALL' if all_dbs else 'FLUSHDB'))

-        return self._get_simple_response()
+        return self.get_response()

     
     def info(self):
         """
     
     def info(self):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> info = r.info()
         >>> info and isinstance(info, dict)
         True
         >>> info = r.info()
         >>> info and isinstance(info, dict)
         True


@@ -853,81 +953,64 @@ class Redis(object):
         self.connect()
         self._write('INFO\r\n')
         info = dict()
         self.connect()
         self._write('INFO\r\n')
         info = dict()

-        for l in self._get_value().split('\r\n'):
+        for l in self.get_response().split('\r\n'):

             if not l:
                 continue
             k, v = l.split(':', 1)
             info[k] = int(v) if v.isdigit() else v
         return info
     
             if not l:
                 continue
             k, v = l.split(':', 1)
             info[k] = int(v) if v.isdigit() else v
         return info
     

-    def _get_value(self, negative_as_nil=False):
+    def auth(self, passwd):
+        self.connect()
+        self._write('AUTH %s\r\n' % passwd)
+        return self.get_response()
+    
+    def get_response(self):

         data = self._read().strip()
         data = self._read().strip()

-        if data == 'nil' or (negative_as_nil and data == '-1'):
-            return
-        elif data[0] == '-':
-            self._check_for_error(data)
+        if not data:
+            self.disconnect()
+            raise ConnectionError("Socket closed on remote end")
+        c = data[0]
+        if c == '-':
+            raise ResponseError(data[5:] if data[:5] == '-ERR ' else data[1:])
+        if c == '+':
+            return data[1:]
+        if c == '*':
+            try:
+                num = int(data[1:])
+            except (TypeError, ValueError):
+                raise InvalidResponse("Cannot convert multi-response header '%s' to integer" % data)
+            result = list()
+            for i in range(num):
+                result.append(self._get_value())
+            return result
+        return self._get_value(data)
+    
+    def _get_value(self, data=None):
+        data = data or self._read().strip()
+        if data == '$-1':
+            return None

         try:
         try:

-            l = int(data)
-        except (TypeError, ValueError):
-            raise ResponseError("Cannot parse response '%s' as data length." % data)
+            c, i = data[0], (int(data[1:]) if data.find('.') == -1 else float(data[1:]))
+        except ValueError:
+            raise InvalidResponse("Cannot convert data '%s' to integer" % data)
+        if c == ':':
+            return i
+        if c != '$':
+            raise InvalidResponse("Unkown response prefix for '%s'" % data)

         buf = []
         buf = []

-        while l > 0:
+        while True:

             data = self._read()
             data = self._read()

-            l -= len(data)
-            if len(data) > l:
-                # we got the ending crlf
-                data = data.rstrip()
+            i -= len(data)

             buf.append(data)
             buf.append(data)

-        if l == 0:
-            # the data has a trailing crlf embedded, let's restore it
-            buf.append(self._read())
-        return ''.join(buf)
-    
-    def _get_simple_response(self):
-        data = self._read().strip()
-        if data[0] == '+':
-            return data[1:]
-        self._check_for_error(data)
-        raise InvalidResponse("Cannot parse first line '%s' for a simple response." % data, data)
-
-    def _get_numeric_response(self, allow_negative=True):
-        data = self._read().strip()
-        try:
-            value = int(data)
-        except (TypeError, ValueError), e:
-            pass
-        else:
-            if not allow_negative and value < 0:
-                self._check_for_error(data)
-            return value
-        self._check_for_error(data)
-        raise InvalidResponse("Cannot parse first line '%s' for a numeric response: %s." % (data, e), data)
-        
-    def _get_multi_response(self):
-        results = list()
+            if i < 0:
+                break
+        data = ''.join(buf)[:-2]

         try:
         try:

-            num = self._get_numeric_response(allow_negative=False)
-        except InvalidResponse, e:
-            if e.args[1] == 'nil':
-                return results
-            raise
-        while num:
-            results.append(self._get_value(negative_as_nil=True))
-            num -= 1
-        return results
-        
-    def _check_for_error(self, data):
-        if not data or data[0] != '-':
-            return
-        if data.startswith('-ERR'):
-            raise ResponseError(data[4:].strip())
-        try:
-            error_len = int(data[1:])
-        except (TypeError, ValueError):
-            raise ResponseError("Unknown error format '%s'." % data)
-        error_message = self._read().strip()[5:]
-        raise ResponseError(error_message)
-        
+            return int(data) if data.find('.') == -1 else decimal.Decimal(data)
+        except (ValueError, decimal.InvalidOperation):
+            return data.decode(self.charset)
+    

     def disconnect(self):
         if isinstance(self._sock, socket.socket):
             try:
     def disconnect(self):
         if isinstance(self._sock, socket.socket):
             try:


@@ -939,10 +1022,11 @@ class Redis(object):
             
     def connect(self):
         """
             
     def connect(self):
         """

-        >>> r = Redis()
+        >>> r = Redis(db=9)

         >>> r.connect()
         >>> isinstance(r._sock, socket.socket)
         True
         >>> r.connect()
         >>> isinstance(r._sock, socket.socket)
         True

+        >>> r.disconnect()

         >>> 
         """
         if isinstance(self._sock, socket.socket):
         >>> 
         """
         if isinstance(self._sock, socket.socket):


@@ -955,9 +1039,13 @@ class Redis(object):
         else:
             self._sock = sock
             self._fp = self._sock.makefile('r')
         else:
             self._sock = sock
             self._fp = self._sock.makefile('r')

-        
+            if self.db:
+                self.select(self.db)
+            if self.nodelay is not None:
+                self._sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, self.nodelay)
+                

             
 if __name__ == '__main__':
     import doctest
     doctest.testmod()
             
 if __name__ == '__main__':
     import doctest
     doctest.testmod()

-    
\ No newline at end of file
+