def zadd(self, name, *args, **kwargs):
"""
Set any number of score, element-name pairs to the key ``name``. Pairs
can be specified in two ways:
As *args, in the form of: score1, name1, score2, name2, ...
or as **kwargs, in the form of: name1=score1, name2=score2, ...
The following example would add four values to the 'my-key' key:
redis.zadd('my-key', 1.1, 'name1', 2.2, 'name2', name3=3.3, name4=4.4)
"""
if len(args) % 2 != 0:
raise redis.RedisError("ZADD requires an equal number of "
"values and scores")
zset = self._db.setdefault(name, {})
added = 0
for score, value in zip(*[args[i::2] for i in range(2)]):
if value not in zset:
added += 1
try:
zset[value] = float(score)
except ValueError:
raise redis.ResponseError("value is not a valid float")
for value, score in kwargs.items():
if value not in zset:
added += 1
try:
zset[value] = float(score)
except ValueError:
raise redis.ResponseError("value is not a valid float")
return added
def hincrbyfloat(self, name, key, amount=1.0):
"""Increment the value of key in hash name by floating amount"""
try:
amount = float(amount)
except ValueError:
raise redis.ResponseError("value is not a valid float")
try:
current = float(self._db.setdefault(name, _Hash()).get(key, '0'))
except ValueError:
raise redis.ResponseError("hash value is not a valid float")
new = current + amount
self._db[name][key] = to_bytes(new)
return new
def hincrbyfloat(self, name, key, amount=1.0):
"Increment the value of ``key`` in hash ``name`` by floating ``amount``"
try:
amount = float(amount)
except ValueError:
raise redis.ResponseError("value is not a valid float")
try:
current = float(
self._db.setdefault(name, _StrKeyDict()).get(key, '0'))
except ValueError:
raise redis.ResponseError("hash value is not a valid float")
new = current + amount
self._db[name][key] = new
return new
def get(self, name):
value = self._db.get(name)
if isinstance(value, _StrKeyDict):
raise redis.ResponseError("WRONGTYPE Operation against a key "
"holding the wrong kind of value")
if value is not None:
return to_bytes(value)
def load_all_params(self, agent, key=None, errors='raise'):
"""loads agent params from the database under the given name"""
assert errors in (
'raise', 'warn', 'print',
'ignore'), "errors must be 'raise','warn','print' or 'ignore'"
if errors == 'raise':
#Main function
key = key or self.default_params_key
raw = self.redis.get(key)
if raw is None:
raise redis.ResponseError(
"Params not found under key '%s' (got None)" % key)
all_params = self.loads(raw)
set_all_param_values(
list(agent.agent_states) + agent.policy + agent.action_layers,
all_params)
else:
#Error handling
try:
return self.load_all_params(agent, key=key, errors='raise')
except:
exc_type, exc, tb = sys.exc_info()
if errors == 'warn':
warn(str(exc))
elif errors == 'print':
print(str(exc))
def decr(self, name, amount=1):
try:
self._db[name] = self._db.get(name, 0) - amount
except TypeError:
raise redis.ResponseError("value is not an integer or out of "
"range.")
return self._db[name]
def rename(self, src, dst):
try:
value = self._db[src]
except KeyError:
raise redis.ResponseError("No such key: %s" % src)
self._db[dst] = value
del self._db[src]
return True
def test_disabled_config_get(aggregator, redis_auth, redis_instance):
redis_check = Redis('redisdb', {}, {})
with mock.patch.object(redis.client.Redis, 'config_get') as get:
get.side_effect = redis.ResponseError()
redis_check.check(redis_instance)
assert len(aggregator.service_checks('redis.can_connect')) == 1
sc = aggregator.service_checks('redis.can_connect')[0]
assert sc.tags == ['foo:bar', 'redis_host:{}'.format(HOST), 'redis_port:6379', 'redis_role:master']
def mget(self, keys, *args):
all_keys = self._list_or_args(keys, args)
found = []
if not all_keys:
raise redis.ResponseError(
"wrong number of arguments for 'mget' command")
for key in all_keys:
found.append(self._db.get(key))
return found
def zunionstore(self, dest, keys, aggregate=None):
"""
Union multiple sorted sets specified by ``keys`` into
a new sorted set, ``dest``. Scores in the destination will be
aggregated based on the ``aggregate``, or SUM if none is provided.
"""
if not keys:
raise redis.ResponseError("At least one key must be specified "
"for ZINTERSTORE/ZUNIONSTORE")
self._zaggregate(dest, keys, aggregate, lambda x: True)
def incr(self, name, amount=1):
"""
Increments the value of ``key`` by ``amount``. If no key exists,
the value will be initialized as ``amount``
"""
try:
self._db[name] = self._db.get(name, 0) + amount
except TypeError:
raise redis.ResponseError("value is not an integer or out of "
"range.")
return self._db[name]
def _get_comparator_and_val(self, value):
try:
if isinstance(value, string_types) and value.startswith('('):
comparator = operator.lt
actual_value = float(value[1:])
else:
comparator = operator.le
actual_value = float(value)
except ValueError:
raise redis.ResponseError('min or max is not a float')
return comparator, actual_value
def _strtod_key_func(self, arg):
# str()'ing the arg is important! Don't ever remove this.
arg = str(arg)
end = c_char_p()
val = _strtod(arg, pointer(end))
# real Redis also does an isnan check, not sure if
# that's needed here or not.
if end.value:
raise redis.ResponseError(
"One or more scores can't be converted into double")
else:
return val
def zinterstore(self, dest, keys, aggregate=None):
"""
Intersect multiple sorted sets specified by ``keys`` into
a new sorted set, ``dest``. Scores in the destination will be
aggregated based on the ``aggregate``, or SUM if none is provided.
"""
if not keys:
raise redis.ResponseError("At least one key must be specified "
"for ZINTERSTORE/ZUNIONSTORE")
# keys can be a list or a dict so it needs to be converted to
# a list first.
list_keys = list(keys)
valid_keys = set(self._db.get(list_keys[0], {}))
for key in list_keys[1:]:
valid_keys.intersection_update(self._db.get(key, {}))
return self._zaggregate(dest, keys, aggregate,
lambda x: x in valid_keys)
def execute_command_via_connection(r, *argv, **kwargs):
# the first time this is called, simulate an ASK exception.
# after that behave normally.
# capture all the requests and responses.
if not test.execute_command_calls:
e = redis.ResponseError("ASK 1 127.0.0.1:7003")
test.execute_command_calls.append({'exception': e})
raise e
try:
result = execute_command_via_connection_original(
r, *argv, **kwargs)
test.execute_command_calls.append({
'argv': argv,
'kwargs': kwargs,
'result': result
})
return result
except Exception as e:
test.execute_command_calls.append({
'argv': argv,
'kwargs': kwargs,
'exception': e
})
raise e
def lset(self, name, index, value):
try:
self._db.get(name, [])[index] = value
except IndexError:
raise redis.ResponseError("index out of range")
def incrbyfloat(self, name, amount=1.0):
try:
self._db[name] = float(self._db.get(name, '0')) + amount
except (TypeError, ValueError):
raise redis.ResponseError("value is not a valid float.")
return self._db[name]
