def tag_id_name_count_list_by_tag_admin(limit, offset):
id_count = redis.zrevrange(REDIS_TAG_ADMIN, offset, offset+limit-1, True, int)
zsite_list = Zsite.mc_get_list(map(itemgetter(0), id_count))
r = []
for i,count in zip(zsite_list, map(itemgetter(1),id_count)):
r.append((i.id, i.name, count))
return r, redis.zcard(REDIS_TAG_ADMIN)
def id_score_list_by_hot():
result = redis.get(REDIS_REC_TAG_ID_SCORE)
if result is None:
result = redis.zrevrange(REDIS_REC_TAG, 0, REDIS_REC_USER_TAG_LIMIT-1, True)
result = [map(int, i) for i in result]
redis.setex(REDIS_REC_TAG_ID_SCORE, dumps_id_score(result), ONE_DAY)
else:
result = loads_id_score(result)
return result
def id_by_tag_admin(tag_id, offset):
r = redis.zrevrange(
REDIS_TAG_ADMIN_TAG_ID%tag_id,
offset,offset
)
if r:
id = r[0]
else:
id = 0
return id
def id_score_list_by_user_id(user_id):
key = REDIS_REC_USER_TAG_CAN_REC%user_id
result = redis.get(key)
if result is None:
key_tag = REDIS_REC_USER_TAG%user_id
if redis.exists(key_tag): #第一次初始化
result = redis.zrevrange(key_tag, 0, REDIS_REC_USER_TAG_LIMIT-1, True)
id_score_list_new(user_id, result)
else:
result = None
else:
result = loads_id_score(result)
return result
def id_list_by_str(self, query, limit=7):
name_list = query.replace('`', "'").split()
if not name_list:
return []
name_list.sort()
name_key = '`'.join(name_list)
id_list = self._get_cache(name_key)
id_list = None #TODO REMOVE
ZSET_CID = self.ZSET_CID
if id_list is None:
mkey = ZSET_CID%name_key
if len(name_list)>1 and not redis.exists(mkey):
p = redis.pipeline()
p.zinterstore(mkey, map(ZSET_CID.__mod__, name_list), 'MAX')
p.expire(mkey, EXPIRE)
p.execute()
id_list = redis.zrevrange(mkey, 0, 10)
id_list = list(map(int, id_list))
#id = self.id_by_name(query)
#if id:
# id = int(id)
# if len(id_list) > 5:
# id_list.insert(4, id)
# else:
# id_list.append(id)
#id_list = unique(id_list)
self._set_cache(name_key, id_list)
#print redis.zrevrange(mkey, 0, 10,True)
#print id_list
return id_list[:limit]
def rec_read_user_topic_score_incr(user_id, tag_id, score=1, tag_score=None):
key = REDIS_REC_USER_TAG%user_id
if score == inf:
score_list = redis.zrevrange(key, 0, 0, True, int)
if score_list:
score = max(1, score_list[0][1])
else:
score = 1
redis.zadd(key, tag_id, score)
elif score == ninf:
redis.zrem(key, tag_id)
else:
redis.zincrby(key, tag_id, score)
if tag_score is None:
tag_score = score
redis.zincrby(REDIS_REC_TAG, tag_id, tag_score)
# zrank < REDIS_REC_USER_TAG_LIMIT的时候
# 并且不在读完的redis时候 , 进入候选的推荐主题
if redis.zrevrank(key, tag_id) < REDIS_REC_USER_TAG_LIMIT :
if not redis.sismember(REDIS_REC_TAG_USER_IS_EMPTY%tag_id, user_id):
_rec_topic_new_by_user_id_topic_id_score(user_id, tag_id)
def po_id_list_by_tag_id_cid(tag_id, cid, limit, offset):
id_list = redis.zrevrange(REDIS_TAG_CID % (tag_id, cid), offset,
limit + offset - 1)
return id_list
def rec_read_log_by_user_id(user_id, limit, offset):
key = REDIS_REC_USER_LOG%user_id
return redis.zrevrange(key, offset, offset+limit-1)
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
def po_id_list_by_tag_id_cid(tag_id, cid, limit, offset):
id_list = redis.zrevrange( REDIS_TAG_CID%(tag_id, cid), offset, limit+offset-1 )
return id_list
def user_list_count_by_feed_import_user():
id_count_list = redis.zrevrange(REDIS_FEED_IMPORT_USER, 0, -1, True, int)
zsite_list = Zsite.mc_get_list(map(itemgetter(0), id_count_list))
for i, count in zip(zsite_list, map(itemgetter(1), id_count_list)):
i.feed_import_count = count
return zsite_list
def user_list_count_by_feed_import_user():
id_count_list = redis.zrevrange(REDIS_FEED_IMPORT_USER, 0, -1, True, int)
zsite_list = Zsite.mc_get_list(map(itemgetter(0), id_count_list))
for i, count in zip(zsite_list, map(itemgetter(1), id_count_list)):
i.feed_import_count = count
return zsite_list
