Connecting to Redis¶
Generic Client¶
-
class
redis.client.
Redis
(host='localhost', port=6379, db=0, password=None, socket_timeout=None, socket_connect_timeout=None, socket_keepalive=None, socket_keepalive_options=None, connection_pool=None, unix_socket_path=None, encoding='utf-8', encoding_errors='strict', charset=None, errors=None, decode_responses=False, retry_on_timeout=False, retry_on_error=[], ssl=False, ssl_keyfile=None, ssl_certfile=None, ssl_cert_reqs='required', ssl_ca_certs=None, ssl_ca_path=None, ssl_check_hostname=False, ssl_password=None, ssl_validate_ocsp=False, max_connections=None, single_connection_client=False, health_check_interval=0, client_name=None, username=None, retry=None, redis_connect_func=None)[source]¶ Implementation of the Redis protocol.
This abstract class provides a Python interface to all Redis commands and an implementation of the Redis protocol.
Pipelines derive from this, implementing how the commands are sent and received to the Redis server. Based on configuration, an instance will either use a ConnectionPool, or Connection object to talk to redis.
-
classmethod
from_url
(url, **kwargs)[source]¶ Return a Redis client object configured from the given URL
For example:
redis://[[username]:[password]]@localhost:6379/0 rediss://[[username]:[password]]@localhost:6379/0 unix://[[username]:[password]]@/path/to/socket.sock?db=0
Three URL schemes are supported:
- redis:// creates a TCP socket connection. See more at: <https://www.iana.org/assignments/uri-schemes/prov/redis>
- rediss:// creates a SSL wrapped TCP socket connection. See more at: <https://www.iana.org/assignments/uri-schemes/prov/rediss>
unix://
: creates a Unix Domain Socket connection.
The username, password, hostname, path and all querystring values are passed through urllib.parse.unquote in order to replace any percent-encoded values with their corresponding characters.
There are several ways to specify a database number. The first value found will be used:
- A
db
querystring option, e.g. redis://localhost?db=0 - If using the redis:// or rediss:// schemes, the path argument of the url, e.g. redis://localhost/0
- A
db
keyword argument to this function.
If none of these options are specified, the default db=0 is used.
All querystring options are cast to their appropriate Python types. Boolean arguments can be specified with string values “True”/”False” or “Yes”/”No”. Values that cannot be properly cast cause a
ValueError
to be raised. Once parsed, the querystring arguments and keyword arguments are passed to theConnectionPool
’s class initializer. In the case of conflicting arguments, querystring arguments always win.
-
load_external_module
(funcname, func)[source]¶ This function can be used to add externally defined redis modules, and their namespaces to the redis client.
funcname - A string containing the name of the function to create func - The function, being added to this class.
ex: Assume that one has a custom redis module named foomod that creates command named ‘foo.dothing’ and ‘foo.anotherthing’ in redis. To load function functions into this namespace:
from redis import Redis from foomodule import F r = Redis() r.load_external_module(“foo”, F) r.foo().dothing(‘your’, ‘arguments’)
For a concrete example see the reimport of the redisjson module in tests/test_connection.py::test_loading_external_modules
-
lock
(name, timeout=None, sleep=0.1, blocking_timeout=None, lock_class=None, thread_local=True)[source]¶ Return a new Lock object using key
name
that mimics the behavior of threading.Lock.If specified,
timeout
indicates a maximum life for the lock. By default, it will remain locked until release() is called.sleep
indicates the amount of time to sleep per loop iteration when the lock is in blocking mode and another client is currently holding the lock.blocking_timeout
indicates the maximum amount of time in seconds to spend trying to acquire the lock. A value ofNone
indicates continue trying forever.blocking_timeout
can be specified as a float or integer, both representing the number of seconds to wait.lock_class
forces the specified lock implementation.thread_local
indicates whether the lock token is placed in thread-local storage. By default, the token is placed in thread local storage so that a thread only sees its token, not a token set by another thread. Consider the following timeline:- time: 0, thread-1 acquires my-lock, with a timeout of 5 seconds.
- thread-1 sets the token to “abc”
- time: 1, thread-2 blocks trying to acquire my-lock using the
- Lock instance.
- time: 5, thread-1 has not yet completed. redis expires the lock
- key.
- time: 5, thread-2 acquired my-lock now that it’s available.
- thread-2 sets the token to “xyz”
- time: 6, thread-1 finishes its work and calls release(). if the
- token is not stored in thread local storage, then thread-1 would see the token value as “xyz” and would be able to successfully release the thread-2’s lock.
In some use cases it’s necessary to disable thread local storage. For example, if you have code where one thread acquires a lock and passes that lock instance to a worker thread to release later. If thread local storage isn’t disabled in this case, the worker thread won’t see the token set by the thread that acquired the lock. Our assumption is that these cases aren’t common and as such default to using thread local storage.
-
parse_response
(connection, command_name, **options)[source]¶ Parses a response from the Redis server
-
pipeline
(transaction=True, shard_hint=None)[source]¶ 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.
-
classmethod
Connection Pools¶
-
class
redis.connection.
ConnectionPool
(connection_class=<class 'redis.connection.Connection'>, max_connections=None, **connection_kwargs)[source]¶ Create a connection pool.
If max_connections
is set, then this object raisesConnectionError
when the pool’s limit is reached.By default, TCP connections are created unless
connection_class
is specified. UseUnixDomainSocketConnection
for unix sockets.Any additional keyword arguments are passed to the constructor of
connection_class
.-
disconnect
(inuse_connections=True)[source]¶ Disconnects connections in the pool
If
inuse_connections
is True, disconnect connections that are current in use, potentially by other threads. Otherwise only disconnect connections that are idle in the pool.
-
classmethod
from_url
(url, **kwargs)[source]¶ Return a connection pool configured from the given URL.
For example:
redis://[[username]:[password]]@localhost:6379/0 rediss://[[username]:[password]]@localhost:6379/0 unix://[[username]:[password]]@/path/to/socket.sock?db=0
Three URL schemes are supported:
- redis:// creates a TCP socket connection. See more at: <https://www.iana.org/assignments/uri-schemes/prov/redis>
- rediss:// creates a SSL wrapped TCP socket connection. See more at: <https://www.iana.org/assignments/uri-schemes/prov/rediss>
unix://
: creates a Unix Domain Socket connection.
The username, password, hostname, path and all querystring values are passed through urllib.parse.unquote in order to replace any percent-encoded values with their corresponding characters.
There are several ways to specify a database number. The first value found will be used:
- A
db
querystring option, e.g. redis://localhost?db=0 - If using the redis:// or rediss:// schemes, the path argument of the url, e.g. redis://localhost/0
- A
db
keyword argument to this function.
If none of these options are specified, the default db=0 is used.
All querystring options are cast to their appropriate Python types. Boolean arguments can be specified with string values “True”/”False” or “Yes”/”No”. Values that cannot be properly cast cause a
ValueError
to be raised. Once parsed, the querystring arguments and keyword arguments are passed to theConnectionPool
’s class initializer. In the case of conflicting arguments, querystring arguments always win.
-