本文整理汇总了Python中redis.StrictRedis.register_script方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.register_script方法的具体用法?Python StrictRedis.register_script怎么用?Python StrictRedis.register_script使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.register_script方法的5个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: QueueClient
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import register_script [as 别名]
class QueueClient(object):
"""Interface to a Redis queue/hashmap combo for managing account sync
allocation.
"""
# Lua scripts for atomic assignment and conflict-free unassignment.
ASSIGN = """
local k = redis.call('RPOP', KEYS[1])
if k then
local s = redis.call('HSETNX', KEYS[2], k, ARGV[1])
if s then
return k
end
end"""
UNASSIGN = """
if redis.call('HGET', KEYS[1], KEYS[2]) == ARGV[1] then
return redis.call('HDEL', KEYS[1], KEYS[2])
else
return 0
end
"""
def __init__(self, zone):
self.zone = zone
redis_host = config["ACCOUNT_QUEUE_REDIS_HOSTNAME"]
redis_db = config["ACCOUNT_QUEUE_REDIS_DB"]
self.redis = StrictRedis(
host=redis_host, db=redis_db, socket_connect_timeout=SOCKET_CONNECT_TIMEOUT, socket_timeout=SOCKET_TIMEOUT
)
def all(self):
"""
Returns all keys being tracked (either pending in the queue, or
already assigned).
"""
p = self.redis.pipeline(transaction=True)
p.hgetall(self._hash)
p.lrange(self._queue, 0, -1)
unassigned, assigned = p.execute()
return {int(k) for k in itertools.chain(unassigned, assigned)}
def assigned(self):
"""
Returns a dictionary of all currently assigned key/value pairs (keys
are coerced to integers).
"""
return {int(k): v for k, v in self.redis.hgetall(self._hash).items()}
def enqueue(self, key):
"""
Adds a new key onto the pending queue.
"""
self.redis.lpush(self._queue, key)
def claim_next(self, value):
"""
Pulls the next key off of the pending queue (if any exists), and sets
it to `value` in the hash. Returns None if the queue is empty or if the
key is already present in the hash; otherwise returns the key.
"""
s = self.redis.register_script(self.ASSIGN)
return s(keys=[self._queue, self._hash], args=[value])
def unassign(self, key, value):
"""
Removes `key` from the hash, if and only if it is present and set to
`value` (to prevent removing a key actually assigned to someone else).
"""
s = self.redis.register_script(self.UNASSIGN)
return s(keys=[self._hash, key], args=[value])
def qsize(self):
"""
Returns current length of the queue.
"""
return self.redis.llen(self._queue)
@property
def _queue(self):
return "unassigned_{}".format(self.zone)
@property
def _hash(self):
return "assigned_{}".format(self.zone)
示例2: StrictRedis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import register_script [as 别名]
from redis import StrictRedis
import os
if __name__ == "__main__":
redis = StrictRedis(host='redis')
actions = {}
for fn in os.listdir('./src/Actions'):
print(fn)
with open("./src/Actions/{fn}".format(fn=fn)) as f:
actions[fn] = redis.register_script(f.read())
print(actions.items())
print(redis.hgetall('game_state'))
示例3: TimeSeries
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import register_script [as 别名]
class TimeSeries(object):
"""
Returns a new TimeSeries object.
Example:
>>> ts = TimeSeries(Redis(port=6380))
>>> ts.add('spam.*','f',1,100,1000,'sum')
>>> ts.add('blah.*','f',1,100,1000,'avg')
>>> ts.update({'spam.1': 10, 'blah.1': 10},0)
>>> ts.update({'spam.1': 20, 'blah.1': 20},0)
>>> ts.update({'spam.1': 10, 'blah.1': 10},1)
>>> ts.get('spam.1',0,10,1)
[30.0, 10.0, None, None, None, None, None, None, None, None]
>>> ts.get('blah.1',0,10,1)
[15.0, 10.0, None, None, None, None, None, None, None, None]
"""
def __init__(self, redis=None):
self.rules = []
if redis is None:
self.redis = StrictRedis()
else:
self.redis = redis
self._register_scripts()
def _register_scripts(self):
self.scripts = {}
for method, kwargs in LUA_METHODS.iteritems():
script = LUA_TEMPLATE.render(**kwargs)
self.scripts[method] = self.redis.register_script(script)
def add(self, pattern, fmt, step, chunk, ttl, method):
"""
Add a timeseries rule. `pattern` should be a python regular
expression (see https://docs.python.org/2/howto/regex.html).
Any key later added which matches this expression will be saved
according to the rule.
`fmt` is a single character for the data type. See
https://docs.python.org/3/library/struct.html#format-characters
for a list of possible format characters.
Time series data is organized into chunks which are stored in a
single redis key. This allows data to expire after a certain
period of time. `chunk` controls how many time series points to
store in a single chunk and `ttl` is how many seconds to keep that
chunk alive.
`method` specifies how multiple data points received in a
single time step are handled. `method` may be 'avg', 'min',
'max', 'last', 'sum', or 'rate'.
"""
if method not in LUA_METHODS:
raise ValueError("unknown method %s" % method)
if fmt not in LUA_FORMAT:
raise ValueError("unknown format %s" % fmt)
p = re.compile(pattern)
rule = Rule(p, fmt, step, chunk, ttl, method)
self.rules.append(rule)
def load(self, line):
"""
Load rule from string `line`. line should have the format:
pattern format step chunk ttl method
all separated by spaces. If the regular expression has
spaces you can enclose it in parentheses.
"""
self.add(*shlex.split(line))
def get(self, name, start, stop, step):
"""
Fetch a timeseries from start to stop in steps of step.
start and stop should be unix timestamps, and step should
be in seconds.
"""
# find rule with the greatest step which matches `name`
# and has rule.step <= `step`
for rule in reversed(sorted(self.rules,key=lambda x: x.step)):
if rule.pattern.match(name) and rule.step <= step:
break
else:
msg = 'No rule found for %s with step < %i' % (name, step)
raise RuntimeError(msg)
index_start = start - start % rule.chunk
offset_start = (start % rule.chunk)//rule.step
index_stop = stop - stop % rule.chunk
offset_stop = (stop % rule.chunk)//rule.step
if rule.method == 'avg':
fmt = rule.fmt + 'I'
else:
fmt = rule.fmt + 'B'
chunk_size = struct.calcsize(fmt)*rule.chunk
p = self.redis.pipeline()
for i in range(index_start,index_stop+1,rule.chunk):
p.get('ts:%s:%i:%i:%s' % (rule.fmt,rule.step,i,name))
chunks = map(partial(pad,size=chunk_size),p.execute())
#.........这里部分代码省略.........
示例4: tonumber
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import register_script [as 别名]
v = tonumber(v)
if max == nil or v > max then
max = v
end
end
end
if max == nil then
return max
else
return string.format('%.15g', max)
end
"""
_hmincrby = redis.register_script(HMINCRBY)
_setavgmax = redis.register_script(SETAVGMAX)
_hmincrbyfloat = redis.register_script(HMINCRBYFLOAT)
_hmincr = redis.register_script(HMINCR)
_hdivh = redis.register_script(HDIVH)
_hdivk = redis.register_script(HDIVK)
_avgrange = redis.register_script(AVGRANGE)
_maxrange = redis.register_script(MAXRANGE)
def setavgmax(key, client=None):
"""
Sets the average and max values for crates in the hash key + ':crate:avg'
and key + ':crate:max' respectively. Similarly for cards, where the card
for a crate is indexed with the field crate*512 + card*32.
"""
keys = [key, key + ':crate:avg', key + ':crate:max', key + ':card:avg', key + ':card:max']
示例5: TopTalkers
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import register_script [as 别名]
class TopTalkers(object):
def __init__(self, redis_host='localhost', redis_port=6379):
self.client = StrictRedis(host=redis_host, port=redis_port)
self._is_full_inner = self.client.register_script(LUA_IS_FULL_INNER)
self._clear = self.client.register_script(LUA_CLEAR)
self._get = self.client.register_script(LUA_GET)
self._add = self.client.register_script(LUA_ADD)
self._top_n_keys = self.client.register_script(LUA_TOP_N_KEYS)
self._top_n_keys_counts = self.client.register_script(
LUA_TOP_N_KEYS_COUNTS)
def is_full_inner(self, redis_table, redis_size):
r = self._is_full_inner(keys=[redis_table, redis_size])
return bool(r)
def clear(self, redis_table):
"""
table -> None
"""
self._clear(keys=[redis_table])
def is_full(self, redis_table, redis_size):
"""
(table, size) -> bool
"""
return self.is_full_inner(redis_table, redis_size)
def get(self, redis_table, key):
"""
(table, key) -> count or None
"""
count = self._get(keys=[redis_table, key])
if count is None:
return count
return int(count)
def contains(self, redis_table, key):
"""
(table, key) -> bool
"""
count = self._get(keys=[redis_table, key])
return count is not None
def add(self, redis_table, redis_size, key):
"""
(table, size, key) -> None
"""
self._add(keys=[redis_table, redis_size, key])
def top_n_keys(self, redis_table, n):
"""
(table, n) -> list of keys
"""
return self._top_n_keys(keys=[redis_table, n])
def top_n_keys_counts(self, redis_table, redis_size, n):
"""
(table, size, n) -> list of (key, count)
"""
rr = self._top_n_keys_counts(keys=[redis_table, redis_size, n])
pairs = []
for i in range(len(rr) / 2):
pair = (rr[i * 2], int(rr[i * 2 + 1]))
pairs.append(pair)
return pairs