README.rst 26.9 KB
Newer Older
A
andy 已提交
1 2
redis-py
========
A
andy 已提交
3 4 5

The Python interface to the Redis key-value store.

A
andy 已提交
6 7
.. image:: https://secure.travis-ci.org/andymccurdy/redis-py.png?branch=master
        :target: http://travis-ci.org/andymccurdy/redis-py
8 9 10 11
.. image:: https://readthedocs.org/projects/redis-py/badge/?version=latest&style=flat
        :target: https://redis-py.readthedocs.io/en/latest/
.. image:: https://badge.fury.io/py/redis.svg
        :target: https://pypi.org/project/redis/
A
andy 已提交
12

A
andy 已提交
13 14
Installation
------------
A
andy 已提交
15

A
andy 已提交
16 17 18 19 20 21
redis-py requires a running Redis server. See `Redis's quickstart
<http://redis.io/topics/quickstart>`_ for installation instructions.

To install redis-py, simply:

.. code-block:: bash
A
andy 已提交
22 23 24 25 26

    $ sudo pip install redis

or alternatively (you really should be using pip though):

A
andy 已提交
27 28
.. code-block:: bash

A
andy 已提交
29 30
    $ sudo easy_install redis

A
andy 已提交
31 32 33
or from source:

.. code-block:: bash
A
andy 已提交
34 35 36 37

    $ sudo python setup.py install


A
andy 已提交
38 39 40 41
Getting Started
---------------

.. code-block:: pycon
A
andy 已提交
42 43 44 45 46 47 48 49

    >>> import redis
    >>> r = redis.StrictRedis(host='localhost', port=6379, db=0)
    >>> r.set('foo', 'bar')
    True
    >>> r.get('foo')
    'bar'

50 51 52 53 54 55 56 57
By default, all responses are returned as `bytes` in Python 3 and `str` in
Python 2. The user is responsible for decoding to Python 3 strings or Python 2
unicode objects.

If **all** string responses from a client should be decoded, the user can
specify `decode_responses=True` to `StrictRedis.__init__`. In this case, any
Redis command that returns a string type will be decoded with the `encoding`
specified.
N
nsantiago2719 已提交
58

A
andy 已提交
59 60
API Reference
-------------
A
andy 已提交
61

A
andy 已提交
62 63 64 65
The `official Redis command documentation <http://redis.io/commands>`_ does a
great job of explaining each command in detail. redis-py exposes two client
classes that implement these commands. The StrictRedis class attempts to adhere
to the official command syntax. There are a few exceptions:
A
andy 已提交
66

A
andy 已提交
67
* **SELECT**: Not implemented. See the explanation in the Thread Safety section
A
andy 已提交
68
  below.
A
andy 已提交
69
* **DEL**: 'del' is a reserved keyword in the Python syntax. Therefore redis-py
A
andy 已提交
70
  uses 'delete' instead.
A
andy 已提交
71 72
* **CONFIG GET|SET**: These are implemented separately as config_get or config_set.
* **MULTI/EXEC**: These are implemented as part of the Pipeline class. The
A
andy 已提交
73 74 75
  pipeline is wrapped with the MULTI and EXEC statements by default when it
  is executed, which can be disabled by specifying transaction=False.
  See more about Pipelines below.
A
andy 已提交
76
* **SUBSCRIBE/LISTEN**: Similar to pipelines, PubSub is implemented as a separate
A
andy 已提交
77 78 79
  class as it places the underlying connection in a state where it can't
  execute non-pubsub commands. Calling the pubsub method from the Redis client
  will return a PubSub instance where you can subscribe to channels and listen
A
andy 已提交
80 81 82 83
  for messages. You can only call PUBLISH from the Redis client (see
  `this comment on issue #151
  <https://github.com/andymccurdy/redis-py/issues/151#issuecomment-1545015>`_
  for details).
M
Marc Abramowitz 已提交
84
* **SCAN/SSCAN/HSCAN/ZSCAN**: The \*SCAN commands are implemented as they
A
Andy McCurdy 已提交
85 86 87 88
  exist in the Redis documentation. In addition, each command has an equivilant
  iterator method. These are purely for convenience so the user doesn't have
  to keep track of the cursor while iterating. Use the
  scan_iter/sscan_iter/hscan_iter/zscan_iter methods for this behavior.
A
andy 已提交
89 90 91 92 93

In addition to the changes above, the Redis class, a subclass of StrictRedis,
overrides several other commands to provide backwards compatibility with older
versions of redis-py:

A
andy 已提交
94
* **LREM**: Order of 'num' and 'value' arguments reversed such that 'num' can
A
andy 已提交
95
  provide a default value of zero.
A
andy 已提交
96
* **ZADD**: Redis specifies the 'score' argument before 'value'. These were swapped
A
andy 已提交
97
  accidentally when being implemented and not discovered until after people
A
andy 已提交
98
  were already using it. The Redis class expects \*args in the form of:
A
andy 已提交
99
  `name1, score1, name2, score2, ...`
A
andy 已提交
100
* **SETEX**: Order of 'time' and 'value' arguments reversed.
A
andy 已提交
101 102


A
andy 已提交
103 104
More Detail
-----------
A
andy 已提交
105

A
andy 已提交
106 107
Connection Pools
^^^^^^^^^^^^^^^^
A
andy 已提交
108 109 110 111 112 113

Behind the scenes, redis-py uses a connection pool to manage connections to
a Redis server. By default, each Redis instance you create will in turn create
its own connection pool. You can override this behavior and use an existing
connection pool by passing an already created connection pool instance to the
connection_pool argument of the Redis class. You may choose to do this in order
A
andy 已提交
114 115 116 117
to implement client side sharding or have finer grain control of how
connections are managed.

.. code-block:: pycon
A
andy 已提交
118 119 120 121

    >>> pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
    >>> r = redis.Redis(connection_pool=pool)

A
andy 已提交
122 123
Connections
^^^^^^^^^^^
A
andy 已提交
124 125 126 127 128 129 130 131 132 133

ConnectionPools manage a set of Connection instances. redis-py ships with two
types of Connections. The default, Connection, is a normal TCP socket based
connection. The UnixDomainSocketConnection allows for clients running on the
same device as the server to connect via a unix domain socket. To use a
UnixDomainSocketConnection connection, simply pass the unix_socket_path
argument, which is a string to the unix domain socket file. Additionally, make
sure the unixsocket parameter is defined in your redis.conf file. It's
commented out by default.

A
andy 已提交
134 135
.. code-block:: pycon

A
andy 已提交
136 137 138 139 140 141
    >>> r = redis.Redis(unix_socket_path='/tmp/redis.sock')

You can create your own Connection subclasses as well. This may be useful if
you want to control the socket behavior within an async framework. To
instantiate a client class using your own connection, you need to create
a connection pool, passing your class to the connection_class argument.
Ł
Łukasz Jernaś 已提交
142
Other keyword parameters you pass to the pool will be passed to the class
A
andy 已提交
143 144
specified during initialization.

A
andy 已提交
145 146
.. code-block:: pycon

A
andy 已提交
147 148 149
    >>> pool = redis.ConnectionPool(connection_class=YourConnectionClass,
                                    your_arg='...', ...)

A
andy 已提交
150 151
Parsers
^^^^^^^
A
andy 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164

Parser classes provide a way to control how responses from the Redis server
are parsed. redis-py ships with two parser classes, the PythonParser and the
HiredisParser. By default, redis-py will attempt to use the HiredisParser if
you have the hiredis module installed and will fallback to the PythonParser
otherwise.

Hiredis is a C library maintained by the core Redis team. Pieter Noordhuis was
kind enough to create Python bindings. Using Hiredis can provide up to a
10x speed improvement in parsing responses from the Redis server. The
performance increase is most noticeable when retrieving many pieces of data,
such as from LRANGE or SMEMBERS operations.

A
andy 已提交
165
Hiredis is available on PyPI, and can be installed via pip or easy_install
A
andy 已提交
166 167
just like redis-py.

A
andy 已提交
168 169
.. code-block:: bash

A
andy 已提交
170 171 172 173
    $ pip install hiredis

or

A
andy 已提交
174 175
.. code-block:: bash

A
andy 已提交
176 177
    $ easy_install hiredis

A
andy 已提交
178 179
Response Callbacks
^^^^^^^^^^^^^^^^^^
A
andy 已提交
180 181 182 183 184 185 186 187 188 189

The client class uses a set of callbacks to cast Redis responses to the
appropriate Python type. There are a number of these callbacks defined on
the Redis client class in a dictionary called RESPONSE_CALLBACKS.

Custom callbacks can be added on a per-instance basis using the
set_response_callback method. This method accepts two arguments: a command
name and the callback. Callbacks added in this manner are only valid on the
instance the callback is added to. If you want to define or override a callback
globally, you should make a subclass of the Redis client and add your callback
190
to its RESPONSE_CALLBACKS class dictionary.
A
andy 已提交
191 192 193 194 195 196 197

Response callbacks take at least one parameter: the response from the Redis
server. Keyword arguments may also be accepted in order to further control
how to interpret the response. These keyword arguments are specified during the
command's call to execute_command. The ZRANGE implementation demonstrates the
use of response callback keyword arguments with its "withscores" argument.

A
andy 已提交
198 199
Thread Safety
^^^^^^^^^^^^^
A
andy 已提交
200 201 202 203 204 205 206 207 208 209 210 211

Redis client instances can safely be shared between threads. Internally,
connection instances are only retrieved from the connection pool during
command execution, and returned to the pool directly after. Command execution
never modifies state on the client instance.

However, there is one caveat: the Redis SELECT command. The SELECT command
allows you to switch the database currently in use by the connection. That
database remains selected until another is selected or until the connection is
closed. This creates an issue in that connections could be returned to the pool
that are connected to a different database.

A
andy 已提交
212 213 214 215
As a result, redis-py does not implement the SELECT command on client
instances. If you use multiple Redis databases within the same application, you
should create a separate client instance (and possibly a separate connection
pool) for each database.
A
andy 已提交
216 217 218

It is not safe to pass PubSub or Pipeline objects between threads.

A
andy 已提交
219 220
Pipelines
^^^^^^^^^
A
andy 已提交
221 222 223 224 225 226 227 228

Pipelines are a subclass of the base Redis class that provide support for
buffering multiple commands to the server in a single request. They can be used
to dramatically increase the performance of groups of commands by reducing the
number of back-and-forth TCP packets between the client and server.

Pipelines are quite simple to use:

A
andy 已提交
229 230
.. code-block:: pycon

A
andy 已提交
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
    >>> r = redis.Redis(...)
    >>> r.set('bing', 'baz')
    >>> # Use the pipeline() method to create a pipeline instance
    >>> pipe = r.pipeline()
    >>> # The following SET commands are buffered
    >>> pipe.set('foo', 'bar')
    >>> pipe.get('bing')
    >>> # the EXECUTE call sends all buffered commands to the server, returning
    >>> # a list of responses, one for each command.
    >>> pipe.execute()
    [True, 'baz']

For ease of use, all commands being buffered into the pipeline return the
pipeline object itself. Therefore calls can be chained like:

A
andy 已提交
246 247
.. code-block:: pycon

A
andy 已提交
248 249 250 251 252 253 254 255
    >>> pipe.set('foo', 'bar').sadd('faz', 'baz').incr('auto_number').execute()
    [True, True, 6]

In addition, pipelines can also ensure the buffered commands are executed
atomically as a group. This happens by default. If you want to disable the
atomic nature of a pipeline but still want to buffer commands, you can turn
off transactions.

A
andy 已提交
256 257
.. code-block:: pycon

A
andy 已提交
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
    >>> pipe = r.pipeline(transaction=False)

A common issue occurs when requiring atomic transactions but needing to
retrieve values in Redis prior for use within the transaction. For instance,
let's assume that the INCR command didn't exist and we need to build an atomic
version of INCR in Python.

The completely naive implementation could GET the value, increment it in
Python, and SET the new value back. However, this is not atomic because
multiple clients could be doing this at the same time, each getting the same
value from GET.

Enter the WATCH command. WATCH provides the ability to monitor one or more keys
prior to starting a transaction. If any of those keys change prior the
execution of that transaction, the entire transaction will be canceled and a
WatchError will be raised. To implement our own client-side INCR command, we
could do something like this:

A
andy 已提交
276 277
.. code-block:: pycon

A
andy 已提交
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
    >>> with r.pipeline() as pipe:
    ...     while 1:
    ...         try:
    ...             # put a WATCH on the key that holds our sequence value
    ...             pipe.watch('OUR-SEQUENCE-KEY')
    ...             # after WATCHing, the pipeline is put into immediate execution
    ...             # mode until we tell it to start buffering commands again.
    ...             # this allows us to get the current value of our sequence
    ...             current_value = pipe.get('OUR-SEQUENCE-KEY')
    ...             next_value = int(current_value) + 1
    ...             # now we can put the pipeline back into buffered mode with MULTI
    ...             pipe.multi()
    ...             pipe.set('OUR-SEQUENCE-KEY', next_value)
    ...             # and finally, execute the pipeline (the set command)
    ...             pipe.execute()
    ...             # if a WatchError wasn't raised during execution, everything
    ...             # we just did happened atomically.
    ...             break
    ...        except WatchError:
    ...             # another client must have changed 'OUR-SEQUENCE-KEY' between
    ...             # the time we started WATCHing it and the pipeline's execution.
    ...             # our best bet is to just retry.
    ...             continue

Note that, because the Pipeline must bind to a single connection for the
duration of a WATCH, care must be taken to ensure that the connection is
returned to the connection pool by calling the reset() method. If the
Pipeline is used as a context manager (as in the example above) reset()
will be called automatically. Of course you can do this the manual way by
J
John Clover 已提交
307
explicitly calling reset():
A
andy 已提交
308

A
andy 已提交
309 310
.. code-block:: pycon

A
andy 已提交
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
    >>> pipe = r.pipeline()
    >>> while 1:
    ...     try:
    ...         pipe.watch('OUR-SEQUENCE-KEY')
    ...         ...
    ...         pipe.execute()
    ...         break
    ...     except WatchError:
    ...         continue
    ...     finally:
    ...         pipe.reset()

A convenience method named "transaction" exists for handling all the
boilerplate of handling and retrying watch errors. It takes a callable that
should expect a single parameter, a pipeline object, and any number of keys to
be WATCHed. Our client-side INCR command above can be written like this,
which is much easier to read:

A
andy 已提交
329 330
.. code-block:: pycon

A
andy 已提交
331 332 333 334 335 336 337 338 339
    >>> def client_side_incr(pipe):
    ...     current_value = pipe.get('OUR-SEQUENCE-KEY')
    ...     next_value = int(current_value) + 1
    ...     pipe.multi()
    ...     pipe.set('OUR-SEQUENCE-KEY', next_value)
    >>>
    >>> r.transaction(client_side_incr, 'OUR-SEQUENCE-KEY')
    [True]

A
Andy McCurdy 已提交
340 341 342 343
Publish / Subscribe
^^^^^^^^^^^^^^^^^^^

redis-py includes a `PubSub` object that subscribes to channels and listens
A
typos  
Andy McCurdy 已提交
344
for new messages. Creating a `PubSub` object is easy.
A
Andy McCurdy 已提交
345 346 347 348 349 350 351

.. code-block:: pycon

    >>> r = redis.StrictRedis(...)
    >>> p = r.pubsub()

Once a `PubSub` instance is created, channels and patterns can be subscribed
A
typos  
Andy McCurdy 已提交
352
to.
A
Andy McCurdy 已提交
353 354 355 356 357 358 359

.. code-block:: pycon

    >>> p.subscribe('my-first-channel', 'my-second-channel', ...)
    >>> p.psubscribe('my-*', ...)

The `PubSub` instance is now subscribed to those channels/patterns. The
A
typos  
Andy McCurdy 已提交
360 361
subscription confirmations can be seen by reading messages from the `PubSub`
instance.
A
Andy McCurdy 已提交
362 363 364 365 366 367 368 369 370 371 372

.. code-block:: pycon

    >>> p.get_message()
    {'pattern': None, 'type': 'subscribe', 'channel': 'my-second-channel', 'data': 1L}
    >>> p.get_message()
    {'pattern': None, 'type': 'subscribe', 'channel': 'my-first-channel', 'data': 2L}
    >>> p.get_message()
    {'pattern': None, 'type': 'psubscribe', 'channel': 'my-*', 'data': 3L}

Every message read from a `PubSub` instance will be a dictionary with the
A
typos  
Andy McCurdy 已提交
373
following keys.
A
Andy McCurdy 已提交
374 375 376 377 378

* **type**: One of the following: 'subscribe', 'unsubscribe', 'psubscribe',
  'punsubscribe', 'message', 'pmessage'
* **channel**: The channel [un]subscribed to or the channel a message was
  published to
A
typos  
Andy McCurdy 已提交
379 380
* **pattern**: The pattern that matched a published message's channel. Will be
  `None` in all cases except for 'pmessage' types.
A
Andy McCurdy 已提交
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
* **data**: The message data. With [un]subscribe messages, this value will be
  the number of channels and patterns the connection is currently subscribed
  to. With [p]message messages, this value will be the actual published
  message.

Let's send a message now.

.. code-block:: pycon

    # the publish method returns the number matching channel and pattern
    # subscriptions. 'my-first-channel' matches both the 'my-first-channel'
    # subscription and the 'my-*' pattern subscription, so this message will
    # be delivered to 2 channels/patterns
    >>> r.publish('my-first-channel', 'some data')
    2
    >>> p.get_message()
    {'channel': 'my-first-channel', 'data': 'some data', 'pattern': None, 'type': 'message'}
    >>> p.get_message()
    {'channel': 'my-first-channel', 'data': 'some data', 'pattern': 'my-*', 'type': 'pmessage'}

Unsubscribing works just like subscribing. If no arguments are passed to
A
typos  
Andy McCurdy 已提交
402
[p]unsubscribe, all channels or patterns will be unsubscribed from.
A
Andy McCurdy 已提交
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418

.. code-block:: pycon

    >>> p.unsubscribe()
    >>> p.punsubscribe('my-*')
    >>> p.get_message()
    {'channel': 'my-second-channel', 'data': 2L, 'pattern': None, 'type': 'unsubscribe'}
    >>> p.get_message()
    {'channel': 'my-first-channel', 'data': 1L, 'pattern': None, 'type': 'unsubscribe'}
    >>> p.get_message()
    {'channel': 'my-*', 'data': 0L, 'pattern': None, 'type': 'punsubscribe'}

redis-py also allows you to register callback functions to handle published
messages. Message handlers take a single argument, the message, which is a
dictionary just like the examples above. To subscribe to a channel or pattern
with a message handler, pass the channel or pattern name as a keyword argument
A
typos  
Andy McCurdy 已提交
419
with its value being the callback function.
A
Andy McCurdy 已提交
420

A
typos  
Andy McCurdy 已提交
421 422 423 424
When a message is read on a channel or pattern with a message handler, the
message dictionary is created and passed to the message handler. In this case,
a `None` value is returned from get_message() since the message was already
handled.
A
Andy McCurdy 已提交
425 426 427 428 429 430

.. code-block:: pycon

    >>> def my_handler(message):
    ...     print 'MY HANDLER: ', message['data']
    >>> p.subscribe(**{'my-channel': my_handler})
A
typos  
Andy McCurdy 已提交
431
    # read the subscribe confirmation message
A
Andy McCurdy 已提交
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
    >>> p.get_message()
    {'pattern': None, 'type': 'subscribe', 'channel': 'my-channel', 'data': 1L}
    >>> r.publish('my-channel', 'awesome data')
    1
    # for the message handler to work, we need tell the instance to read data.
    # this can be done in several ways (read more below). we'll just use
    # the familiar get_message() function for now
    >>> message = p.get_message()
    MY HANDLER:  awesome data
    # note here that the my_handler callback printed the string above.
    # `message` is None because the message was handled by our handler.
    >>> print message
    None

If your application is not interested in the (sometimes noisy)
A
typos  
Andy McCurdy 已提交
447 448 449 450
subscribe/unsubscribe confirmation messages, you can ignore them by passing
`ignore_subscribe_messages=True` to `r.pubsub()`. This will cause all
subscribe/unsubscribe messages to be read, but they won't bubble up to your
application.
A
Andy McCurdy 已提交
451 452 453 454 455 456 457 458 459

.. code-block:: pycon

    >>> p = r.pubsub(ignore_subscribe_messages=True)
    >>> p.subscribe('my-channel')
    >>> p.get_message()  # hides the subscribe message and returns None
    >>> r.publish('my-channel')
    1
    >>> p.get_message()
J
Jitendra Nair 已提交
460
    {'channel': 'my-channel', 'data': 'my data', 'pattern': None, 'type': 'message'}
A
Andy McCurdy 已提交
461 462 463 464 465 466 467 468

There are three different strategies for reading messages.

The examples above have been using `pubsub.get_message()`. Behind the scenes,
`get_message()` uses the system's 'select' module to quickly poll the
connection's socket. If there's data available to be read, `get_message()` will
read it, format the message and return it or pass it to a message handler. If
there's no data to be read, `get_message()` will immediately return None. This
A
typos  
Andy McCurdy 已提交
469 470
makes it trivial to integrate into an existing event loop inside your
application.
A
Andy McCurdy 已提交
471 472 473 474 475 476 477 478 479 480 481 482

.. code-block:: pycon

    >>> while True:
    >>>     message = p.get_message()
    >>>     if message:
    >>>         # do something with the message
    >>>     time.sleep(0.001)  # be nice to the system :)

Older versions of redis-py only read messages with `pubsub.listen()`. listen()
is a generator that blocks until a message is available. If your application
doesn't need to do anything else but receive and act on messages received from
A
typos  
Andy McCurdy 已提交
483
redis, listen() is an easy way to get up an running.
A
Andy McCurdy 已提交
484 485 486 487 488 489 490 491

.. code-block:: pycon

    >>> for message in p.listen():
    ...     # do something with the message

The third option runs an event loop in a separate thread.
`pubsub.run_in_thread()` creates a new thread and starts the event loop. The
A
typos  
Andy McCurdy 已提交
492
thread object is returned to the caller of `run_in_thread()`. The caller can
A
Andy McCurdy 已提交
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
use the `thread.stop()` method to shut down the event loop and thread. Behind
the scenes, this is simply a wrapper around `get_message()` that runs in a
separate thread, essentially creating a tiny non-blocking event loop for you.
`run_in_thread()` takes an optional `sleep_time` argument. If specified, the
event loop will call `time.sleep()` with the value in each iteration of the
loop.

Note: Since we're running in a separate thread, there's no way to handle
messages that aren't automatically handled with registered message handlers.
Therefore, redis-py prevents you from calling `run_in_thread()` if you're
subscribed to patterns or channels that don't have message handlers attached.

.. code-block:: pycon

    >>> p.subscribe(**{'my-channel': my_handler})
    >>> thread = p.run_in_thread(sleep_time=0.001)
    # the event loop is now running in the background processing messages
    # when it's time to shut it down...
    >>> thread.stop()

A PubSub object adheres to the same encoding semantics as the client instance
it was created from. Any channel or pattern that's unicode will be encoded
using the `charset` specified on the client before being sent to Redis. If the
client's `decode_responses` flag is set the False (the default), the
'channel', 'pattern' and 'data' values in message dictionaries will be byte
strings (str on Python 2, bytes on Python 3). If the client's
`decode_responses` is True, then the 'channel', 'pattern' and 'data' values
will be automatically decoded to unicode strings using the client's `charset`.

PubSub objects remember what channels and patterns they are subscribed to. In
the event of a disconnection such as a network error or timeout, the
PubSub object will re-subscribe to all prior channels and patterns when
reconnecting. Messages that were published while the client was disconnected
cannot be delivered. When you're finished with a PubSub object, call its
`.close()` method to shutdown the connection.

.. code-block:: pycon

    >>> p = r.pubsub()
    >>> ...
    >>> p.close()

A
AngusP 已提交
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550

The PUBSUB set of subcommands CHANNELS, NUMSUB and NUMPAT are also
supported:

.. code-block:: pycon

    >>> r.pubsub_channels()
    ['foo', 'bar']
    >>> r.pubsub_numsub('foo', 'bar')
    [('foo', 9001), ('bar', 42)]
    >>> r.pubsub_numsub('baz')
    [('baz', 0)]
    >>> r.pubsub_numpat()
    1204


J
John Belmonte 已提交
551
Lua Scripting
A
andy 已提交
552
^^^^^^^^^^^^^
A
andy 已提交
553 554 555 556 557 558 559

redis-py supports the EVAL, EVALSHA, and SCRIPT commands. However, there are
a number of edge cases that make these commands tedious to use in real world
scenarios. Therefore, redis-py exposes a Script object that makes scripting
much easier to use.

To create a Script instance, use the `register_script` function on a client
J
John Belmonte 已提交
560
instance passing the Lua code as the first argument. `register_script` returns
A
andy 已提交
561 562
a Script instance that you can use throughout your code.

J
John Belmonte 已提交
563
The following trivial Lua script accepts two parameters: the name of a key and
A
andy 已提交
564
a multiplier value. The script fetches the value stored in the key, multiplies
A
andy 已提交
565 566
it with the multiplier value and returns the result.

A
andy 已提交
567 568
.. code-block:: pycon

A
andy 已提交
569 570 571 572 573 574 575 576 577 578
    >>> r = redis.StrictRedis()
    >>> lua = """
    ... local value = redis.call('GET', KEYS[1])
    ... value = tonumber(value)
    ... return value * ARGV[1]"""
    >>> multiply = r.register_script(lua)

`multiply` is now a Script instance that is invoked by calling it like a
function. Script instances accept the following optional arguments:

A
andy 已提交
579
* **keys**: A list of key names that the script will access. This becomes the
J
John Belmonte 已提交
580 581
  KEYS list in Lua.
* **args**: A list of argument values. This becomes the ARGV list in Lua.
A
andy 已提交
582 583 584 585
* **client**: A redis-py Client or Pipeline instance that will invoke the
  script. If client isn't specified, the client that intiially
  created the Script instance (the one that `register_script` was
  invoked from) will be used.
A
andy 已提交
586 587 588

Continuing the example from above:

A
andy 已提交
589 590
.. code-block:: pycon

A
andy 已提交
591 592 593 594 595
    >>> r.set('foo', 2)
    >>> multiply(keys=['foo'], args=[5])
    10

The value of key 'foo' is set to 2. When multiply is invoked, the 'foo' key is
J
John Belmonte 已提交
596
passed to the script along with the multiplier value of 5. Lua executes the
A
andy 已提交
597 598 599 600 601
script and returns the result, 10.

Script instances can be executed using a different client instance, even one
that points to a completely different Redis server.

A
andy 已提交
602 603
.. code-block:: pycon

A
andy 已提交
604 605 606 607 608
    >>> r2 = redis.StrictRedis('redis2.example.com')
    >>> r2.set('foo', 3)
    >>> multiply(keys=['foo'], args=[5], client=r2)
    15

J
John Belmonte 已提交
609
The Script object ensures that the Lua script is loaded into Redis's script
A
andy 已提交
610 611 612 613 614 615 616 617
cache. In the event of a NOSCRIPT error, it will load the script and retry
executing it.

Script objects can also be used in pipelines. The pipeline instance should be
passed as the client argument when calling the script. Care is taken to ensure
that the script is registered in Redis's script cache just prior to pipeline
execution.

A
andy 已提交
618 619
.. code-block:: pycon

A
andy 已提交
620 621 622 623 624 625
    >>> pipe = r.pipeline()
    >>> pipe.set('foo', 5)
    >>> multiply(keys=['foo'], args=[5], client=pipe)
    >>> pipe.execute()
    [True, 25]

626 627 628 629
Sentinel support
^^^^^^^^^^^^^^^^

redis-py can be used together with `Redis Sentinel <http://redis.io/topics/sentinel>`_
A
Andy McCurdy 已提交
630 631 632 633 634
to discover Redis nodes. You need to have at least one Sentinel daemon running
in order to use redis-py's Sentinel support.

Connecting redis-py to the Sentinel instance(s) is easy. You can use a
Sentinel connection to discover the master and slaves network addresses:
635 636 637 638 639 640 641

.. code-block:: pycon

    >>> from redis.sentinel import Sentinel
    >>> sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
    >>> sentinel.discover_master('mymaster')
    ('127.0.0.1', 6379)
V
Vitja Makarov 已提交
642 643
    >>> sentinel.discover_slaves('mymaster')
    [('127.0.0.1', 6380)]
644

Ł
Łukasz Jernaś 已提交
645
You can also create Redis client connections from a Sentinel instance. You can
A
Andy McCurdy 已提交
646 647
connect to either the master (for write operations) or a slave (for read-only
operations).
648 649 650 651 652 653 654 655 656

.. code-block:: pycon

    >>> master = sentinel.master_for('mymaster', socket_timeout=0.1)
    >>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)
    >>> master.set('foo', 'bar')
    >>> slave.get('foo')
    'bar'

A
Andy McCurdy 已提交
657 658 659 660 661 662
The master and slave objects are normal StrictRedis instances with their
connection pool bound to the Sentinel instance. When a Sentinel backed client
attempts to establish a connection, it first queries the Sentinel servers to
determine an appropriate host to connect to. If no server is found,
a MasterNotFoundError or SlaveNotFoundError is raised. Both exceptions are
subclasses of ConnectionError.
663

A
Andy McCurdy 已提交
664 665 666 667
When trying to connect to a slave client, the Sentinel connection pool will
iterate over the list of slaves until it finds one that can be connected to.
If no slaves can be connected to, a connection will be established with the
master.
V
Vitja Makarov 已提交
668

669
See `Guidelines for Redis clients with support for Redis Sentinel
A
Andy McCurdy 已提交
670
<http://redis.io/topics/sentinel-clients>`_ to learn more about Redis Sentinel.
671

A
Andy McCurdy 已提交
672
Scan Iterators
673 674
^^^^^^^^^^^^^^

M
Marc Abramowitz 已提交
675
The \*SCAN commands introduced in Redis 2.8 can be cumbersome to use. While
A
Andy McCurdy 已提交
676 677 678
these commands are fully supported, redis-py also exposes the following methods
that return Python iterators for convenience: `scan_iter`, `hscan_iter`,
`sscan_iter` and `zscan_iter`.
679 680 681

.. code-block:: pycon

A
Andy McCurdy 已提交
682 683 684 685 686 687 688
    >>> for key, value in (('A', '1'), ('B', '2'), ('C', '3')):
    ...     r.set(key, value)
    >>> for key in r.scan_iter():
    ...     print key, r.get(key)
    A 1
    B 2
    C 3
689

A
andy 已提交
690
Author
A
andy 已提交
691
^^^^^^
A
andy 已提交
692 693 694 695 696 697 698 699 700 701 702

redis-py is developed and maintained by Andy McCurdy (sedrik@gmail.com).
It can be found here: http://github.com/andymccurdy/redis-py

Special thanks to:

* Ludovico Magnocavallo, author of the original Python Redis client, from
  which some of the socket code is still used.
* Alexander Solovyov for ideas on the generic response callback system.
* Paul Hubbard for initial packaging support.