Python StrictRedis.register_script方法代码示例

# 需要导入模块: 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)

# 需要导入模块: 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'))

    

# 需要导入模块: 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())
#.........这里部分代码省略.........

# 需要导入模块: 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']

# 需要导入模块: 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