def migrate_keys(self, host, port, keys, dest_db, timeout, *,
copy=False, replace=False):
"""Atomically transfer keys from one Redis instance to another one.
Keys argument must be list/tuple of keys to migrate.
"""
if not isinstance(host, str):
raise TypeError("host argument must be str")
if not isinstance(timeout, int):
raise TypeError("timeout argument must be int")
if not isinstance(dest_db, int):
raise TypeError("dest_db argument must be int")
if not isinstance(keys, (list, tuple)):
raise TypeError("keys argument must be list or tuple")
if not host:
raise ValueError("Got empty host")
if dest_db < 0:
raise ValueError("dest_db must be greater equal 0")
if timeout < 0:
raise ValueError("timeout must be greater equal 0")
if not keys:
raise ValueError("keys must not be empty")
flags = []
if copy:
flags.append(b'COPY')
if replace:
flags.append(b'REPLACE')
flags.append(b'KEYS')
flags.extend(keys)
fut = self.execute(b'MIGRATE', host, port,
"", dest_db, timeout, *flags)
return wait_ok(fut)
def cluster_add_slots(self, slot, *slots):
"""Assign new hash slots to receiving node."""
slots = (slot,) + slots
if not all(isinstance(s, int) for s in slots):
raise TypeError("All parameters must be of type int")
fut = self._conn.execute(b'CLUSTER', b'ADDSLOTS', *slots)
return wait_ok(fut)
def cluster_del_slots(self, slot, *slots):
"""Set hash slots as unbound in receiving node."""
slots = (slot,) + slots
if not all(isinstance(s, int) for s in slots):
raise TypeError("All parameters must be of type int")
fut = self._conn.execute(b'CLUSTER', b'DELSLOTS', *slots)
return wait_ok(fut)
def xgroup_create(self, stream, group_name, latest_id='$', mkstream=False):
"""Create a consumer group"""
args = [b'CREATE', stream, group_name, latest_id]
if mkstream:
args.append(b'MKSTREAM')
fut = self.execute(b'XGROUP', *args)
return wait_ok(fut)
def cluster_failover(self, force=False):
"""
Forces the slave to start a manual failover of its master instance.
"""
command = force and b'FORCE' or b'TAKEOVER'
fut = self.execute(b'CLUSTER', b'FAILOVER', command)
return wait_ok(fut)
def psetex(self, key, milliseconds, value):
"""Set the value and expiration in milliseconds of a key.
:raises TypeError: if milliseconds is not int
"""
if not isinstance(milliseconds, int):
raise TypeError("milliseconds argument must be int")
fut = self._conn.execute(b'PSETEX', key, milliseconds, value)
return wait_ok(fut)
def rename(self, key, newkey):
"""Renames key to newkey.
:raises ValueError: if key == newkey
"""
if key == newkey:
raise ValueError("key and newkey are the same")
fut = self.execute(b'RENAME', key, newkey)
return wait_ok(fut)
def mset(self, key, value, *pairs):
"""Set multiple keys to multiple values.
:raises TypeError: if len of pairs is not event number
"""
if len(pairs) % 2 != 0:
raise TypeError("length of pairs must be even number")
fut = self._conn.execute(b'MSET', key, value, *pairs)
return wait_ok(fut)
def flushall(self, async_op=False):
"""
Remove all keys from all databases.
:param async_op: lets the entire dataset to be freed asynchronously. \
Defaults to False
"""
if async_op:
fut = self.execute(b'FLUSHALL', b'ASYNC')
else:
fut = self.execute(b'FLUSHALL')
return wait_ok(fut)
def ltrim(self, key, start, stop):
"""Trim an existing list so that it will contain only the specified
range of elements specified.
:raises TypeError: if start or stop is not int
"""
if not isinstance(start, int):
raise TypeError("start argument must be int")
if not isinstance(stop, int):
raise TypeError("stop argument must be int")
fut = self._conn.execute(b'LTRIM', key, start, stop)
return wait_ok(fut)
def client_pause(self, timeout):
"""Stop processing commands from clients for *timeout* milliseconds.
:raises TypeError: if timeout is not int
:raises ValueError: if timeout is less than 0
"""
if not isinstance(timeout, int):
raise TypeError("timeout argument must be int")
if timeout < 0:
raise ValueError("timeout must be greater equal 0")
fut = self.execute(b'CLIENT', b'PAUSE', timeout)
return wait_ok(fut)
def flushdb(self, async_op=False):
"""
Remove all keys from the current database.
:param async_op: lets a single database to be freed asynchronously. \
Defaults to False
"""
if async_op:
fut = self.execute(b'FLUSHDB', b'ASYNC')
else:
fut = self.execute(b'FLUSHDB')
return wait_ok(fut)
def cluster_set_config_epoch(self, config_epoch):
"""Set the configuration epoch in a new node."""
try:
config_epoch = int(config_epoch)
except ValueError:
raise TypeError(
"Expected slot to be of type int, got {}".format(
type(config_epoch)
)
)
fut = self.execute(b'CLUSTER', b'SET-CONFIG-EPOCH', config_epoch)
return wait_ok(fut)
def setex(self, key, seconds, value):
"""Set the value and expiration of a key.
If seconds is float it will be multiplied by 1000
coerced to int and passed to `psetex` method.
:raises TypeError: if seconds is neither int nor float
"""
if isinstance(seconds, float):
return self.psetex(key, int(seconds * 1000), value)
if not isinstance(seconds, int):
raise TypeError("milliseconds argument must be int")
fut = self._conn.execute(b'SETEX', key, seconds, value)
return wait_ok(fut)
def mset(self, *args):
"""Set multiple keys to multiple values or unpack dict to keys & values.
:raises TypeError: if len of args is not event number
:raises TypeError: if len of args equals 1 and it is not a dict
"""
data = args
if len(args) == 1:
if not isinstance(args[0], dict):
raise TypeError("if one arg it should be a dict")
data = chain.from_iterable(args[0].items())
elif len(args) % 2 != 0:
raise TypeError("length of pairs must be even number")
fut = self.execute(b'MSET', *data)
return wait_ok(fut)
def hmset_dict(self, key, *args, **kwargs):
"""Set multiple hash fields to multiple values.
.. deprecated::
HMSET is deprecated since redis 4.0.0, use HSET instead.
dict can be passed as first positional argument:
>>> await redis.hmset_dict(
... 'key', {'field1': 'value1', 'field2': 'value2'})
or keyword arguments can be used:
>>> await redis.hmset_dict(
... 'key', field1='value1', field2='value2')
or dict argument can be mixed with kwargs:
>>> await redis.hmset_dict(
... 'key', {'field1': 'value1'}, field2='value2')
.. note:: ``dict`` and ``kwargs`` not get mixed into single dictionary,
if both specified and both have same key(s) -- ``kwargs`` will win:
>>> await redis.hmset_dict('key', {'foo': 'bar'}, foo='baz')
>>> await redis.hget('key', 'foo', encoding='utf-8')
'baz'
"""
warnings.warn(
"%s.hmset() is deprecated since redis 4.0.0, use %s.hset() instead"
% (self.__class__.__name__, self.__class__.__name__),
DeprecationWarning)
if not args and not kwargs:
raise TypeError("args or kwargs must be specified")
pairs = ()
if len(args) > 1:
raise TypeError("single positional argument allowed")
elif len(args) == 1:
if not isinstance(args[0], dict):
raise TypeError("args[0] must be dict")
elif not args[0] and not kwargs:
raise ValueError("args[0] is empty dict")
pairs = chain.from_iterable(args[0].items())
kwargs_pairs = chain.from_iterable(kwargs.items())
return wait_ok(self.execute(b"HMSET", key, *chain(pairs,
kwargs_pairs)))
def hmset_dict(self, key, *args, **kwargs):
"""Set multiple hash fields to multiple values.
dict can be passed as first positional argument:
>>> yield from redis.hmset_dict(
... 'key', {'field1': 'value1', 'field2': 'value2'})
or keyword arguments can be used:
>>> yield from redis.hmset_dict(
... 'key', field1='value1', field2='value2')
or dict argument can be mixed with kwargs:
>>> yield from redis.hmset_dict(
... 'key', {'field1': 'value1'}, field2='value2')
.. note:: ``dict`` and ``kwargs`` not get mixed into single dictionary,
if both specified and both have same key(s) -- ``kwargs`` will win:
>>> yield from redis.hmset_dict('key', {'foo': 'bar'}, foo='baz')
>>> yield from redis.hget('key', 'foo', encoding='utf-8')
'baz'
"""
if not args and not kwargs:
raise TypeError("args or kwargs must be specified")
pairs = ()
if len(args) > 1:
raise TypeError("single positional argument allowed")
elif len(args) == 1:
if not isinstance(args[0], dict):
raise TypeError("args[0] must be dict")
elif not args[0] and not kwargs:
raise ValueError("args[0] is empty dict")
pairs = chain.from_iterable(args[0].items())
kwargs_pairs = chain.from_iterable(kwargs.items())
return wait_ok(self._conn.execute(
b'HMSET', key, *chain(pairs, kwargs_pairs)))
def migrate_keys(self,
host,
port,
keys,
dest_db,
timeout,
*,
copy=False,
replace=False):
"""Atomically transfer keys from one Redis instance to another one.
Keys argument must be list/tuple of keys to migrate.
"""
if not isinstance(host, str):
raise TypeError("host argument must be str")
if not isinstance(timeout, int):
raise TypeError("timeout argument must be int")
if not isinstance(dest_db, int):
raise TypeError("dest_db argument must be int")
if not isinstance(keys, (list, tuple)):
raise TypeError("keys argument must be list or tuple")
if not host:
raise ValueError("Got empty host")
if dest_db < 0:
raise ValueError("dest_db must be greater equal 0")
if timeout < 0:
raise ValueError("timeout must be greater equal 0")
if not keys:
raise ValueError("keys must not be empty")
flags = []
if copy:
flags.append(b'COPY')
if replace:
flags.append(b'REPLACE')
flags.append(b'KEYS')
flags.extend(keys)
fut = self.execute(b'MIGRATE', host, port, "", dest_db, timeout,
*flags)
return wait_ok(fut)
def set(self, key, value, *, expire=0, pexpire=0, exist=None):
"""Set the string value of a key.
:raises TypeError: if expire or pexpire is not int
"""
if expire and not isinstance(expire, int):
raise TypeError("expire argument must be int")
if pexpire and not isinstance(pexpire, int):
raise TypeError("pexpire argument must be int")
args = []
if expire:
args[:] = [b"EX", expire]
if pexpire:
args[:] = [b"PX", pexpire]
if exist is self.SET_IF_EXIST:
args.append(b"XX")
elif exist is self.SET_IF_NOT_EXIST:
args.append(b"NX")
fut = self.execute(b"SET", key, value, *args)
return wait_ok(fut)
def set(self, key, value, *, expire=0, pexpire=0, exist=None):
"""Set the string value of a key.
:raises TypeError: if expire or pexpire is not int
"""
if expire and not isinstance(expire, int):
raise TypeError("expire argument must be int")
if pexpire and not isinstance(pexpire, int):
raise TypeError("pexpire argument must be int")
args = []
if expire:
args[:] = [b'EX', expire]
if pexpire:
args[:] = [b'PX', pexpire]
if exist is self.SET_IF_EXIST:
args.append(b'XX')
elif exist is self.SET_IF_NOT_EXIST:
args.append(b'NX')
fut = self._conn.execute(b'SET', key, value, *args)
return wait_ok(fut)
def migrate(self, host, port, key, dest_db, timeout, *,
copy=False, replace=False):
"""Atomically transfer a key from a Redis instance to another one."""
if not isinstance(host, str):
raise TypeError("host argument must be str")
if not isinstance(timeout, int):
raise TypeError("timeout argument must be int")
if not isinstance(dest_db, int):
raise TypeError("dest_db argument must be int")
if not host:
raise ValueError("Got empty host")
if dest_db < 0:
raise ValueError("dest_db must be greater equal 0")
if timeout < 0:
raise ValueError("timeout must be greater equal 0")
flags = []
if copy:
flags.append(b'COPY')
if replace:
flags.append(b'REPLACE')
fut = self.execute(b'MIGRATE', host, port,
key, dest_db, timeout, *flags)
return wait_ok(fut)
def migrate(self, host, port, key, dest_db, timeout, *,
copy=False, replace=False):
"""Atomically transfer a key from a Redis instance to another one."""
if not isinstance(host, str):
raise TypeError("host argument must be str")
if not isinstance(timeout, int):
raise TypeError("timeout argument must be int")
if not isinstance(dest_db, int):
raise TypeError("dest_db argument must be int")
if not host:
raise ValueError("Got empty host")
if dest_db < 0:
raise ValueError("dest_db must be greater equal 0")
if timeout < 0:
raise ValueError("timeout must be greater equal 0")
flags = []
if copy:
flags.append(b'COPY')
if replace:
flags.append(b'REPLACE')
fut = self.execute(b'MIGRATE', host, port,
key, dest_db, timeout, *flags)
return wait_ok(fut)
def cluster_reset(self, *, hard: bool = False):
"""Reset a Redis Cluster node."""
reset = hard and b"HARD" or b"SOFT"
fut = self.execute(b"CLUSTER", b"RESET", reset)
return wait_ok(fut)
def swapdb(self, from_index, to_index):
return wait_ok(self.execute(b'SWAPDB', from_index, to_index))
def cluster_reset(self, *, hard=False):
"""Reset a Redis Cluster node."""
reset = hard and b'HARD' or b'SOFT'
fut = self.execute(b'CLUSTER', b'RESET', reset)
return wait_ok(fut)
def cluster_meet(self, ip, port):
"""Force a node cluster to handshake with another node."""
fut = self.execute(b'CLUSTER', b'MEET', ip, port)
return wait_ok(fut)
def cluster_readwrite(self):
"""
Disables read queries for a connection to a Redis Cluster slave node.
"""
fut = self.execute(b"READWRITE")
return wait_ok(fut)
def cluster_readonly(self):
"""
Enables read queries for a connection to a Redis Cluster slave node.
"""
fut = self.execute(b'READONLY')
return wait_ok(fut)
def script_flush(self):
"""Remove all the scripts from the script cache."""
fut = self.execute(b"SCRIPT", b"FLUSH")
return wait_ok(fut)
def script_kill(self):
"""Kill the script currently in execution."""
fut = self.execute(b'SCRIPT', b'KILL')
return wait_ok(fut)
def cluster_meet(self, ip: str, port: int):
"""Force a node cluster to handshake with another node."""
fut = self.execute(b"CLUSTER", b"MEET", ip, port)
return wait_ok(fut)
def debug_sleep(self, timeout):
"""Get debugging information about a key."""
fut = self.execute(b'DEBUG', b'SLEEP', timeout)
return wait_ok(fut)
def flushdb(self):
"""Remove all keys from the current database."""
fut = self.execute('FLUSHDB')
return wait_ok(fut)
def flushall(self):
"""Remove all keys from all databases."""
fut = self.execute(b'FLUSHALL')
return wait_ok(fut)
def xgroup_setid(self, stream, group_name, latest_id='$'):
"""Set the latest ID for a consumer group"""
fut = self.execute(b'XGROUP', b'SETID', stream, group_name, latest_id)
return wait_ok(fut)
def config_rewrite(self):
"""Rewrite the configuration file with the in memory configuration."""
fut = self.execute(b'CONFIG', b'REWRITE')
return wait_ok(fut)
def cluster_forget(self, node_id: str):
"""Remove a node from the nodes table."""
fut = self.execute(b"CLUSTER", b"FORGET", node_id)
return wait_ok(fut)
def client_setname(self, name):
"""Set the current connection name."""
fut = self.execute(b'CLIENT', b'SETNAME', name)
return wait_ok(fut)
def config_set(self, parameter, value):
"""Set a configuration parameter to the given value."""
if not isinstance(parameter, str):
raise TypeError("parameter must be str")
fut = self.execute(b'CONFIG', b'SET', parameter, value)
return wait_ok(fut)
def debug_sleep(self, timeout):
"""Suspend connection for timeout seconds."""
fut = self.execute(b'DEBUG', b'SLEEP', timeout)
return wait_ok(fut)
def cluster_readwrite(self):
"""
Disables read queries for a connection to a Redis Cluster slave node.
"""
fut = self.execute(b'READWRITE')
return wait_ok(fut)
def xgroup_setid(self, stream, group_name, latest_id="$"):
"""Set the latest ID for a consumer group"""
fut = self.execute(b"XGROUP", b"SETID", stream, group_name, latest_id)
return wait_ok(fut)
def cluster_forget(self, node_id):
"""Remove a node from the nodes table."""
fut = self.execute(b'CLUSTER', b'FORGET', node_id)
return wait_ok(fut)
def cluster_readonly(self):
"""
Enables read queries for a connection to a Redis Cluster slave node.
"""
fut = self.execute(b"READONLY")
return wait_ok(fut)
def cluster_replicate(self, node_id):
"""Reconfigure a node as a slave of the specified master node."""
fut = self.execute(b'CLUSTER', b'REPLICATE', node_id)
return wait_ok(fut)
def xgroup_create(self, stream, group_name, latest_id='$'):
"""Create a consumer group"""
fut = self.execute(b'XGROUP', b'CREATE', stream, group_name, latest_id)
return wait_ok(fut)
def cluster_save_config(self):
"""Force the node to save cluster state on disk."""
fut = self.execute(b'CLUSTER', b'SAVECONFIG')
return wait_ok(fut)
def client_setname(self, name):
"""Set the current connection name."""
fut = self.execute(b'CLIENT', b'SETNAME', name)
return wait_ok(fut)
def bgsave(self):
"""Asynchronously save the dataset to disk."""
fut = self.execute(b'BGSAVE')
return wait_ok(fut)
def cluster_replicate(self, node_id: str):
"""Reconfigure a node as a slave of the specified master node."""
fut = self.execute(b"CLUSTER", b"REPLICATE", node_id)
return wait_ok(fut)
def xgroup_destroy(self, stream, group_name):
"""Delete a consumer group"""
fut = self.execute(b"XGROUP", b"DESTROY", stream, group_name)
return wait_ok(fut)
def cluster_save_config(self):
"""Force the node to save cluster state on disk."""
fut = self.execute(b"CLUSTER", b"SAVECONFIG")
return wait_ok(fut)
def config_resetstat(self):
"""Reset the stats returned by INFO."""
fut = self.execute(b'CONFIG', b'RESETSTAT')
return wait_ok(fut)
def bgsave(self):
"""Asynchronously save the dataset to disk."""
fut = self.execute(b'BGSAVE')
return wait_ok(fut)
def bgrewriteaof(self):
"""Asynchronously rewrite the append-only file."""
fut = self.execute(b'BGREWRITEAOF')
return wait_ok(fut)
def slowlog_reset(self):
"""Resets Redis slow queries log."""
fut = self.execute(b'SLOWLOG', b'RESET')
return wait_ok(fut)
def slowlog_reset(self):
"""Resets Redis slow queries log."""
fut = self.execute(b'SLOWLOG', b'RESET')
return wait_ok(fut)
def script_kill(self):
"""Kill the script currently in execution."""
fut = self.execute(b"SCRIPT", b"KILL")
return wait_ok(fut)
def config_rewrite(self):
"""Rewrite the configuration file with the in memory configuration."""
fut = self.execute(b'CONFIG', b'REWRITE')
return wait_ok(fut)
def bgrewriteaof(self):
"""Asynchronously rewrite the append-only file."""
fut = self.execute(b'BGREWRITEAOF')
return wait_ok(fut)