def show_task_lists(r: Redis) -> None:
    f = open(f'proactive_stats/stats.txt', "w+")
    todo = []
    todo = r.lrange(name=TODO_TASK_LIST, start=0, end=-1)
    done = []
    done = r.lrange(name=DONE_TASK_LIST, start=0, end=-1)
    string = f'To-do list:\n'
    for i in todo:
        string += f'{i}\n'
    string += f'\nDone list:\n'
    for i in done:
        string += f'{i}\n'
    f.write(string)
    f.close()
Example #2
0
    def lrange(self, name, start, end):
        """
        Return a slice of the list ``name`` between
        position ``start`` and ``end``
        
        ``start`` and ``end`` can be negative numbers just like
        Python slicing notation

        decode the results
        """
        results = Redis.lrange(self, name, start, end)
        return [result.decode(self.encoding) for result in results]
Example #3
0
class Jedis():
    def __init__(self):
        pool = ConnectionPool(host=cfg.REDIS_HOST, port=cfg.REDIS_PORT)
        self.client = Redis(connection_pool=pool)

    def page_query(self, redis_key, start, end):
        '''
        分页查询
        :param redis_key: redis中的key名称
        :param start:起始页
        :param end:结束页
        :return:
        '''
        return self.client.lrange(name=redis_key, start=start, end=end)

    def len(self, redis_key):
        return self.client.llen(name=redis_key)

    def lpush(self, key, val):
        self.client.lpush(key, val)
Example #4
0
    exit(0)
    # import os
    # print(os.listdir('../data-temp/'))
    # exit(90)
    # for key in red.keys('program-temp-*'):
    #   red.delete(key)
    # exit(0)

    id = 25241424977985538
    count = 0
    for key in red.keys():
        value = None
        if red.type(key) == b'set':
            value = red.smembers(key)
        if red.type(key) == b'list':
            value = red.lrange(key, 0, -1)
        count += len(value)
        # for item in value:
        #   item = int(item)
        #   if item == id:
        #     print(key)
    print(count)
    exit(0)
    l1 = [1, 2, 3, 4, 9, 10, 11, 12]
    l2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
    for item1 in l1:
        for item2 in l2:
            j = judge_req_times()
            is_req_danmaku(item2, item1, j)
            # c = consumer()
            # produce(c, item2, item1)
Example #5
0
class TSStore(object):

    def __init__(self, config):
        self._redis = Redis(host=config.get('redis','host'), 
                            port=int(config.get('redis','port')),
                            db=int(config.get('redis','db')))
        self._delta_secs = int(eval(config.get('timeseries',
                                               'delta_secs')))
        self._expiration_delay_secs = int(eval(config.get('timeseries',
                                                          'expiration_delay_secs')))

    def queries_key(self):
        return 'queries'
    @property
    def queries(self):
        return self._redis.smembers(self.queries_key())
    @queries.setter
    def queries(self, values):
        pipe = self._redis.pipeline()
        pipe.delete(self.queries_key())
        for v in values:
            pipe.sadd(self.queries_key(),
                      v)
        return pipe.execute()

    def _interval_key(self, timestamp):
        return int(timestamp) - int(timestamp) % self._delta_secs
    def _ts_key(self, timestamp, query):
        return 'ts:%(query)s:%(timestamp_key)s'%{'query':query,
                                                 'timestamp_key':self._interval_key(timestamp)}
    def _tweet_key(self, t):
        if type(t) == Tweet:
            return 'tweet:%s'%t.id
        return 'tweet:%s'%t
    def _query_key(self, query):
        return 'query:%s:last_tweet_id'%query

    def _store_tweet(self, pipe, tweet):
        tweet_key = self._tweet_key(tweet)
        pipe.set(tweet_key, tweet.serialize())
        pipe.expire(tweet_key, self._expiration_delay_secs)
    def _reference_tweet(self, pipe, timestamp, query, tweet):
        ts_key = self._ts_key(timestamp, query)
        pipe.lpush(ts_key,tweet.id)
        pipe.expire(ts_key,self._expiration_delay_secs)
    def _update_last_query_tweet(self, pipe, query, tweet):
        query_key = self._query_key(query)
        pipe.set(query_key,tweet.id)
    def append(self, query, tweet):
        pipe = self._redis.pipeline()
        timestamp = time.time()
        self._store_tweet(pipe, tweet)
        self._reference_tweet(pipe, timestamp, query, tweet)
        self._update_last_query_tweet(pipe, query, tweet)
        return pipe.execute()

    def retrieve_ts(self, query, timestamp, n_elements=-1):
        ts_key = self._ts_key(timestamp, query)
        return self._redis.lrange(ts_key, 0, n_elements)
    def retrieve_last_tweet_id(self, query):
        query_key = self._query_key(query)
        return self._redis.get(query_key)
    def retrieve_tweet(self, tweet_id):
        tweet_key = self._tweet_key(tweet_id)
        data = self._redis.get(tweet_key)
        return Tweet.deserialize(data).todict()
    def retrieve(self, query, n_periods=30):
        current_timestamp = now = int(time.time())
        start_timestamp = now - self._delta_secs * n_periods
        tweets = []
        while current_timestamp > start_timestamp:
            current_tweet_ids = self.retrieve_ts(query, current_timestamp)
            tweets.append({'timestamp': current_timestamp,
                           'tweets' : [ self.retrieve_tweet(tid) for tid in current_tweet_ids ] })
            current_timestamp -= self._delta_secs 
        return { 'now' : now,
                 'ts' : tweets }