Ejemplo n.º 1
0
def rec_read(user_id, limit):
    limit = rec_limit_by_time(user_id, limit)
    result = set()
    if limit > 0:
        key_log = REDIS_REC_USER_LOG%user_id
        picker = RecTagPicker(user_id)
        for i in xrange(limit):

            tag_id = picker()
            if not tag_id:
                break

            po_id = rec_read_by_user_id_tag_id(user_id, tag_id)
            if not po_id:
                picker.delete(tag_id)
                continue

            result.add(po_id)

        if result:
            now = time_new_offset()
            t = []
            offset = 0
            for i in result:
                t.append(i)
                t.append(offset+now)
                offset += 0.01

            redis.zadd(key_log, *t)

    return result
Ejemplo n.º 2
0
def rec_limit_by_time(user_id, limit):
    now = time_new_offset()
    last = redis.hget(REDIS_REC_LAST_TIME, user_id) or 0
    times = int((now - int(last) + 59)//60)
    redis.hset(REDIS_REC_LAST_TIME, user_id, now)
    return min(times, limit)
Ejemplo n.º 3
0
def rec_read_by_user_id_tag_id(user_id, tag_id):
    po_id = 0
    from_new = False
    now = time_new_offset()
    ut_id = (user_id, tag_id)
    key_to_rec = REDIS_REC_USER_PO_TO_REC%ut_id
    key_readed = REDIS_REC_USER_TAG_READED%ut_id
    exists_key_to_rec = redis.exists(key_to_rec)
    cache_key_to_rec = False

    for i in xrange(7):
        #如果有可以推荐的缓存 , 读取缓存
        if exists_key_to_rec:
            po_id_list = redis.zrevrange(key_to_rec, 0, 0)
            if po_id_list:
                po_id = po_id_list[0]
                redis.zrem(key_to_rec, po_id)
            else:
                break
        else:
            key_tag_new = REDIS_REC_TAG_NEW%tag_id
            po_id = redis.srandmember(key_tag_new)
            #print 'srandmember' , po_id
            if po_id:
                from_new = True
                last = redis.zrevrange(key_readed, 0 , 0 , True)
                if last and (last[0][1] - now) < ONE_HOUR:
                    cache_key_to_rec = True
            else:
                cache_key_to_rec = True


        if cache_key_to_rec:
            #生成缓存 有效期1天 推荐文章
            p = redis.pipeline()
            #p = redis
            p.zunionstore(key_to_rec, {key_readed:-1, REDIS_REC_TAG_OLD%tag_id:1})
            p.zremrangebyscore(key_to_rec, '-inf', 0)
            p.expire(key_to_rec, ONE_DAY)
            p.execute()
            exists_key_to_rec = True #方便没有的时候跳出循环

        #print 'redis.zcard(key_readed)', redis.zcard(key_to_rec)

        if po_id:
            redis.zadd(key_readed, po_id, now)
            if redis.zrank(REDIS_REC_USER_LOG%user_id, po_id) is not None:
                po_id = 0

        if po_id:
            break

    if po_id:
        redis.hincrby(REDIS_REC_PO_TIMES, po_id, 1)

        if from_new:
            if redis.hget(REDIS_REC_PO_TIMES, po_id) >= REDIS_REC_PO_SHOW_TIMES:
                redis.srem(key_tag_new, po_id)
                _user_tag_old_rank(po_id, tag_id)
        #else:
                #redis.zincrby(key, po_id, 1)
        else:
            k = random()
            if k < 0.01:
                _user_tag_old_rank(po_id, tag_id)

    return po_id