PEP 3156 implementation of the redis protocol.
Project description
Redis client for the PEP 3156 Python event loop.
This Redis library is a completely asynchronous, non-blocking client for a Redis server. It depends on asyncio (PEP 3156) and therefor it requires Python 3.3 or 3.4. If you’re new to asyncio, it can be helpful to check out the asyncio documentation first.
Features
Works for the asyncio (PEP3156) event loop
No dependencies except asyncio
Connection pooling
Automatic conversion from unicode (Python) to bytes (inside Redis.)
Bytes and str protocols.
Completely tested
Blocking calls and transactions supported
Streaming of some multi bulk replies
Pubsub support
Trollius support: There is a fork by Ben Jolitz that has the necessary changes for using this asyncio-redis library with Trollius.
Installation
pip install asyncio_redis
Documentation
View documentation at read-the-docs
The connection class
A asyncio_redis.Connection instance will take care of the connection and will automatically reconnect, using a new transport when the connection drops. This connection class also acts as a proxy to a asyncio_redis.RedisProtocol instance; any Redis command of the protocol can be called directly at the connection.
import asyncio
import asyncio_redis
@asyncio.coroutine
def example():
# Create Redis connection
connection = yield from asyncio_redis.Connection.create(host='127.0.0.1', port=6379)
# Set a key
yield from connection.set('my_key', 'my_value')
# When finished, close the connection.
connection.close()
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.run_until_complete(example())
Connection pooling
Requests will automatically be distributed among all connections in a pool. If a connection is blocking because of –for instance– a blocking rpop, another connection will be used for new commands.
import asyncio
import asyncio_redis
@asyncio.coroutine
def example():
# Create Redis connection
connection = yield from asyncio_redis.Pool.create(host='127.0.0.1', port=6379, poolsize=10)
# Set a key
yield from connection.set('my_key', 'my_value')
# When finished, close the connection pool.
connection.close()
Transactions example
import asyncio
import asyncio_redis
@asyncio.coroutine
def example():
# Create Redis connection
connection = yield from asyncio_redis.Pool.create(host='127.0.0.1', port=6379, poolsize=10)
# Create transaction
transaction = yield from connection.multi()
# Run commands in transaction (they return future objects)
f1 = yield from transaction.set('key', 'value')
f2 = yield from transaction.set('another_key', 'another_value')
# Commit transaction
yield from transaction.exec()
# Retrieve results
result1 = yield from f1
result2 = yield from f2
# When finished, close the connection pool.
connection.close()
It’s recommended to use a large enough poolsize. A connection will be occupied as long as there’s a transaction running in there.
Pubsub example
import asyncio
import asyncio_redis
@asyncio.coroutine
def example():
# Create connection
connection = yield from asyncio_redis.Connection.create(host='127.0.0.1', port=6379)
# Create subscriber.
subscriber = yield from connection.start_subscribe()
# Subscribe to channel.
yield from subscriber.subscribe([ 'our-channel' ])
# Inside a while loop, wait for incoming events.
while True:
reply = yield from subscriber.next_published()
print('Received: ', repr(reply.value), 'on channel', reply.channel)
# When finished, close the connection.
connection.close()
LUA Scripting example
import asyncio
import asyncio_redis
code = \
"""
local value = redis.call('GET', KEYS[1])
value = tonumber(value)
return value * ARGV[1]
"""
@asyncio.coroutine
def example():
connection = yield from asyncio_redis.Connection.create(host='127.0.0.1', port=6379)
# Set a key
yield from connection.set('my_key', '2')
# Register script
multiply = yield from connection.register_script(code)
# Run script
script_reply = yield from multiply.run(keys=['my_key'], args=['5'])
result = yield from script_reply.return_value()
print(result) # prints 2 * 5
# When finished, close the connection.
connection.close()
Example using the Protocol class
import asyncio
import asyncio_redis
@asyncio.coroutine
def example():
loop = asyncio.get_event_loop()
# Create Redis connection
transport, protocol = yield from loop.create_connection(
asyncio_redis.RedisProtocol, '127.0.0.1', 6379)
# Set a key
yield from protocol.set('my_key', 'my_value')
# Get a key
result = yield from protocol.get('my_key')
print(result)
# Close transport when finished.
transport.close()
if __name__ == '__main__':
asyncio.get_event_loop().run_until_complete(example())
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for asyncio_redis-0.14.2-py3-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | feda9b544e932cd9d57400b4368d971e46453fcc8499585aa6f7632b1af00951 |
|
MD5 | 1e2cdd8737fdfa4b2ba26b90b7b8493f |
|
BLAKE2b-256 | 78fae2f8a60d9e02e60438d23229326241e099c45094225ded4e372655656624 |