def deletelocation(locationkey): locations = querylocationkeys('L-' + str(locationkey)) if (len(locations)) <= 0: return jsonify({'result': False}) else: locationfullname = locations[0]['acname'] + '%L-' + str( locationkey) + '%' start = redis.zrank('locationfragments', locationfullname) previous = start - 1 locationfragment = locationfullname commonfragment = redis.zrange('locationfragments', start + 1, start + 1) while (len(locationfragment) > 0): locationfragment = redis.zrange('locationfragments', previous, previous) if (locationfragment[0][-1] == '%' or (len(commonfragment) > 0 and locationfragment[0] == commonfragment[0][0:-1])): break else: previous = previous - 1 redis.zremrangebyrank('locationfragments', previous + 1, start) redis.delete('L-' + str(locationkey)) return jsonify({'result': True})
def wrapper(*args, **kwargs): if len(args) == 1: handler = args[0] blog_id = handler.get_argument("blog_id", None) if not blog_id: blog_id = redis.zrange('blog.list', -1, -1) if blog_id: blog_id = redis.zrange('blog.list', -1, -1)[0] else: handler.write("请先在管理后台添加预发布的文章") handler.finish() return else: blog_id = args[1] blog = redis.hgetall(blog_id) if not blog: with open(utils.decrypt(blog_id), 'r') as p: lines = p.readlines() or [''] title = lines[0] create_at = int(os.path.getctime(utils.decrypt(blog_id)) or 1504724902) content = utils.md_parse(''.join(lines[2:-1])) redis.hset(blog_id, 'title', title) redis.hset(blog_id, 'create_at', create_at) redis.hset(blog_id, 'content', content) return func(*args, **kwargs)
def wrapper(*args, **kwargs): if len(args) == 1: handler = args[0] blog_id = handler.get_argument("blog_id", None) if not blog_id: blog_id = redis.zrange('blog.list', -1, -1) if blog_id: blog_id = redis.zrange('blog.list', -1, -1)[0] else: handler.write("请先在管理后台添加预发布的文章") handler.finish() return else: blog_id = args[1] blog = redis.hgetall(blog_id) if not blog: with open(utils.decrypt(blog_id), 'r') as p: lines = p.readlines() or [''] title = lines[0] create_at = int( os.path.getctime(utils.decrypt(blog_id)) or 1504724902) content = utils.md_parse(''.join(lines[2:-1])) redis.hset(blog_id, 'title', title) redis.hset(blog_id, 'create_at', create_at) redis.hset(blog_id, 'content', content) return func(*args, **kwargs)
def render(self, *args, **kwargs): tags = redis.smembers('blog.tag') data = {} for tag in tags: data[tag] = len(redis.zrange("blog.tag.%s" % tag, 0, -1)) kwargs['tags'] = data return super(BaseHandler, self).render(*args, **kwargs)
def _clean_up_entries_from_shard(self, object_ids, task_ids, shard_index): redis = self.state.redis_clients[shard_index] # Clean up (in the future, save) entries for non-empty objects. object_ids_locs = set() object_ids_infos = set() for object_id in object_ids: # OL. obj_loc = redis.zrange(OBJECT_LOCATION_PREFIX + object_id, 0, -1) if obj_loc: object_ids_locs.add(object_id) # OI. obj_info = redis.hgetall(OBJECT_INFO_PREFIX + object_id) if obj_info: object_ids_infos.add(object_id) # Form the redis keys to delete. keys = [TASK_TABLE_PREFIX + k for k in task_ids] keys.extend([OBJECT_LOCATION_PREFIX + k for k in object_ids_locs]) keys.extend([OBJECT_INFO_PREFIX + k for k in object_ids_infos]) if not keys: return # Remove with best effort. num_deleted = redis.delete(*keys) log.info( "Removed {} dead redis entries of the driver from redis shard {}.". format(num_deleted, shard_index)) if num_deleted != len(keys): log.warning( "Failed to remove {} relevant redis entries" " from redis shard {}.".format(len(keys) - num_deleted))
def leave_chat(redis, chat_id, user): """ 离开群组 :param redis: :param chat_id: :param user: :return: """ key_chat_group = CHAT_GRUOP.format(chat_id=chat_id) key_user_seen = CHAT_USER_SEEN.format(user=user) key_chat_message_ids = CHAT_MESSAGE_GEN_IDS.format(chat_id=chat_id) key_chat_message = CHAT_MESSAGE.format(chat_id=chat_id) p = redis.pipeline() p.zrem(key_chat_group, user) p.zrem(key_user_seen, chat_id) # 查找群组剩余成员数量 p.zcard(key_chat_group) if not p.execute()[-1]: # 删除群组 p.delete(key_chat_message) p.delete(key_chat_message_ids) p.execute() else: oldest = redis.zrange(key_chat_group, 0, 0, withscores=True) # 删除那些已经被所有成员阅读过的消息。 redis.zremrangebyscore(key_chat_group, 0, oldest[0][1])
def poll_queue(redis): while 1: item = redis.zrange('delayed:queue:', 0, 0, withscores=True) # 任务集合没有任务,或者任务的执行时间未到。 if not item or item[0][1] > time.time(): time.sleep(0.01) continue # 解码要被执行的任务,弄清除它应该被推入哪个任务队列。 item = item[0][0] identifier, queue, name, args = json.loads(item) # 为了对任务进行移动尝试获取锁 # 细粒度锁 locked = acquire_lock(redis, identifier) if not locked: continue # 将任务推入适当的任务队列里面。 if redis.zrem('delayed:queue:', item): redis.lpush('queue:' + queue, item) release_lock(redis, identifier, locked) ##################################################################################################################### # 延迟的优先级任务队列 # ['high-delayed', 'medium-delayed', 'low-delayed']
def suggest_product_for(self, products, max_results=6): product_ids = [product.id for product in products] if len(products) == 1: suggestions = redis.zrange(self.get_product_key(product_ids[0]), 0, -1, desc=True)[:max_results] else: flat_ids = ''.join([str(id) for id in product_ids]) tmp_key = 'tmp_{}'.format(flat_ids) keys = [self.get_product_key(id) for id in product_ids] redis.zunionstore(tmp_key, keys) redis.zrem(tmp_key, *product_ids) suggestions = redis.zrange(tmp_key, 0, -1, desc=True)[:max_results] redis.delete(tmp_key) suggested_product_ids = [int(id) for id in suggestions] suggested_products = list(Product.objects.filter(id__in=suggested_product_ids)) suggested_products.sort(key=lambda x: suggested_product_ids.index(x.id)) return suggested_products
def clean_counter(redis): """ 清理计数器,保留最新的120个样本 :param redis: :return: """ # 为了平等地处理更新频率各不相同的多个计数器,程序需要记录清理操作执行的次数。 passes = 0 while 1: p = redis.pipeline(True) start = time.time() # 渐进地遍历所有已知的计数器 index = 0 while index < redis.zcard('test:known:'): # 取得被检擦计数器的数据 hash = redis.zrange('test:known:', index, index) index += 1 if not hash: break hash = hash[0] prec = int(hash.partition(":")[0]) # 因为清理程序每60秒就会循环一次,所以需要根据计数器的更新频率来判断是否真的有必要对计数器进行清理。 bprec = int(prec // 60) or 1 # 如果整个计数器在这次循环里不需要进行清理,那么检擦下一个计数器 if passes % bprec: continue hkey = 'test:count:' + hash # print hkey # 更具给定的精度以及需要b保留的样本数量,计算出我们需要保留什么时间之前的样本。 cutoff = time.time() - SAMPLE_COUNT * prec samples = map(int, redis.hkeys(hkey)) samples.sort() remove = bisect.bisect_right(samples, cutoff) if remove: print "===========================================" print hkey, samples[:remove] redis.hdel(hkey, *samples[:remove]) if remove == len(samples): try: # 尝试修改计数器散列之前对其进行监视 p.watch(hkey) if not p.hlen(hkey): p.multi() p.zrem('test:known:', hash) p.execute() # 在删除一个计数器的情况下,下次循环可以使用与本次循环相同的索引 index -= 1 else: p.unwatch() except WatchError: pass passes += 1 duration = min(int(time.time() - start) + 1, 60) print "sleep" time.sleep(max(60 - duration, 1))
def join(self, player): if player.table == self: return # Already part of this table. if player.table is not None: player.table.leave(player) # Player has to leave old table msg = Message('JOINED') # Tell all the other players msg.player_name = player.name # that a new player has joined. self.send(msg) player.table = self # Register the new player with self.players.append(player) # this table. # Get a list of all the other players on this table others = redis.zrange(self.players_key, 0, -1) # Check if the player exists (race condition I guess) score = redis.zscore(self.players_key, player.name) if score is None: # Add new player to the player list redis.zadd(self.players_key, player.name, 0) # Add player to the turn list if he/she wasn't already there redis.zadd(self.turns_key, player.name, time.time()) # Prepare joined messages for all existing players msgs = [] for other in others: if other == player.name: continue msg = Message('JOINED') msg.player_name = other msgs.append(msg) # Prepare passed message to set correct turn current = self._get_artist() msg = Message('PASSED', player_name=current) if player.name == current: msg.word = redis.get(self.word_key) end_time = time.time() + 120 if not redis.setnx(self.end_key, end_time): # Clock's already started! end_time = redis.get(self.end_key) else: end_time = redis.get(self.end_key) assert (end_time is not None) msg.end_time = end_time msgs.append(msg) # Send all the prepared messages gevent.joinall([gevent.spawn(player.send, x) for x in msgs])
def jobs(cls): # BUG # scheduler = redbeat.schedulers.RedBeatScheduler(app=queue.queue) # return scheduler.schedule # HACK # https://github.com/sibson/redbeat/issues/155 redis = redbeat.schedulers.get_redis(queue.queue) conf = redbeat.schedulers.RedBeatConfig(queue.queue) keys = redis.zrange(conf.schedule_key, 0, -1) return [redbeat.schedulers.RedBeatSchedulerEntry.from_key(key, app=queue.queue) for key in keys]
def join(self, player): if player.table == self: return # Already part of this table. if player.table is not None: player.table.leave(player) # Player has to leave old table msg = Message('JOINED') # Tell all the other players msg.player_name = player.name # that a new player has joined. self.send(msg) player.table = self # Register the new player with self.players.append(player) # this table. # Get a list of all the other players on this table others = redis.zrange(self.players_key, 0, -1) # Check if the player exists (race condition I guess) score = redis.zscore(self.players_key, player.name) if score is None: # Add new player to the player list redis.zadd(self.players_key, player.name, 0) # Add player to the turn list if he/she wasn't already there redis.zadd(self.turns_key, player.name, time.time()) # Prepare joined messages for all existing players msgs = [] for other in others: if other == player.name: continue msg = Message('JOINED') msg.player_name = other msgs.append(msg) # Prepare passed message to set correct turn current = self._get_artist() msg = Message('PASSED', player_name=current) if player.name == current: msg.word = redis.get(self.word_key) end_time = time.time() + 120 if not redis.setnx(self.end_key, end_time): # Clock's already started! end_time = redis.get(self.end_key) else: end_time = redis.get(self.end_key) assert(end_time is not None) msg.end_time = end_time msgs.append(msg) # Send all the prepared messages gevent.joinall([gevent.spawn(player.send, x) for x in msgs])
def delete_message_by_value(text, all=False): if not all: if redis.zrem('message', text): print('删除成功', text) else: c = input('你确认删除所有的消息吗yes/no') if c == 'yes': messages = redis.zrange('message', 0, -1) for m in messages: if redis.zrem('message', m): print('删除成功', m) else: print('删除取消')
def _pass_turn(self, player_name, guesser=None, score=None): # Get the next player next_player = redis.zrange(self.turns_key, 1, 1) # Are we playing with ourself? if next_player: next_player = next_player[0] else: next_player = player_name # Set the new word word = redis.set(self.word_key, get_next_word().text) # Clear the skip key redis.delete(self.skip_key) # Tell everyone who's turn it is msg = Message('PASSED', player_name=next_player) msg.end_time = time.time() + 120 redis.set(self.end_key, msg.end_time) if score is not None: msg.guesser = guesser msg.score = score self.send(msg) # Ten points to win the game if score >= 10: # Send the won message self.send(Message('WON', player_name=guesser)) # Clear all scores players = redis.zrange(self.players_key, 0, -1) scores = dict((x, 0) for x in players) redis.zadd(self.players_key, **scores) # Move the old player to the end of the turn list redis.zadd(self.turns_key, player_name, time.time())
def fetch_pending_message(redis, recipient): """ 获取消息 :param redis: :param recipient: :return: """ key_user_seen = CHAT_USER_SEEN.format(user=recipient) # 获取最后接收到的消息ID seen = redis.zrange(key_user_seen, 0, -1, withscores=True) p = redis.pipeline() for chat_id, seen_id in seen: key_chat_message = CHAT_MESSAGE.format(chat_id=chat_id) p.zrangebyscore(key_chat_message, seen_id + 1, 'inf') chat_info = zip(seen, p.execute()) for i, ((chat_id, seen_id), messages) in enumerate(chat_info): if not messages: continue key_chat_group = CHAT_GRUOP.format(chat_id=chat_id) messages[:] = map(json.loads, messages) # 使用最新收到的消息来更新群组有序集合。 seen_id = messages[-1]['id'] redis.zadd(key_chat_group, {recipient: seen_id}) # 找出那些所有人都已经阅读过的消息 min_id = redis.zrange(key_chat_group, 0, 0, withscores=True) # 更新已读消息有序集合 p.zadd(key_user_seen, {chat_id: seen_id}) if min_id: key_chat_message = CHAT_MESSAGE.format(chat_id=chat_id) # 清除那些已经被所有人阅读过的消息 p.zremrangebyscore(key_chat_message, 0, min_id[0][1]) chat_info[i] = (chat_id, messages) p.execute() return chat_info
def gethotelfragments(prefix, pagelength): prefix = prefix.lower() listpart = 50 start = redis.zrank('hotelfragments', prefix) if start < 0: return [] hotelarray = [] while (len(hotelarray) != pagelength): range = redis.zrange('hotelfragments', start, start + listpart - 1) start += listpart if not range or len(range) <= 0: break for entry in range: minlen = min(len(entry), len(prefix)) if entry[0:minlen] != prefix[0:minlen]: pagelength = len(hotelarray) break if entry[-1] == '%' and len(hotelarray) != pagelength: hotel = {} hotelfull = entry[0:-1] indexwithperc = hotelfull.rfind('%') hotelid = entry[indexwithperc + 1:-1] hotelname = entry[0:indexwithperc] hotelproperties = redis.lrange(hotelid, 0, -1) if len(hotelproperties) > 0: hotel['id'] = hotelproperties[0] hotel['displayname'] = hotelproperties[1] hotel['acname'] = hotelproperties[2] hotel['image'] = hotelproperties[3] hotel['latitude'] = hotelproperties[4] hotel['longitude'] = hotelproperties[5] hotel['thirdpartyrating'] = hotelproperties[6] hotelarray.append(hotel) return hotelarray
def getlocationfragments(prefix, pagelength): prefix = prefix.lower() listpart = 50 start = redis.zrank('locationfragments', prefix) if start < 0: return [] locationarray = [] while (len(locationarray) != pagelength): range = redis.zrange('locationfragments', start, start + listpart - 1) start += listpart if not range or len(range) <= 0: break for entry in range: minlen = min(len(entry), len(prefix)) if entry[0:minlen] != prefix[0:minlen]: pagelength = len(locationarray) break if entry[-1] == '%' and len(locationarray) != pagelength: location = {} locationfull = entry[0:-1] indexwithperc = locationfull.rfind('%') locationid = entry[indexwithperc + 1:-1] locationname = entry[0:indexwithperc] locationproperties = redis.lrange(locationid, 0, -1) if len(locationproperties) > 0: location['id'] = locationproperties[0] location['displayname'] = locationproperties[1] location['acname'] = locationproperties[2] location['icon'] = locationproperties[3] location['latitude'] = locationproperties[4] location['longitude'] = locationproperties[5] locationarray.append(location) return locationarray
def publish_article(redis, user, title, link): user_id = user.split(':')[-1] article_id = str(int(redis.zrange("nArticles", 0, 0)[0]) + 1) redis.hset("article:" + article_id, "title", title) redis.hset("article:" + article_id, "upvotes", 1) redis.hset("article:" + article_id, "user", user_id) redis.hset("article:" + article_id, "link", link) redis.hset("article:" + article_id, "time", time.time()) redis.hset("article:" + article_id, "comments", 0) redis.hincrby(name=user, key="submissions", amount=1) redis.hincrby(name=user, key="karma", amount=1) redis.sadd("uSubmissions:" + user_id, article_id) redis.zadd("tArticles", 1, article_id) redis.zadd("nArticles", time.time(), article_id) return article_id
def show_message(): messages = redis.zrange('message', 0, -1, desc=True) for m in messages: print(m)
headers={ 'content-type': 'application/json', 'Authorization': 'Bearer 041fff2f1e9950579315d9a8d629ef9f-5b7c44123e8fc34c65951f4d3332b96b' }) responce_json = response.json() price = responce_json['prices'][0] loc = dateutil.parser.parse(price['time']) now_price['time'] = int(loc.timestamp() / 60) now_price['close'] = float(price['bids'][0]['price']) last_no = redis.zcard("fx") - 1 db_price = json.loads(redis.zrange("fx", last_no, last_no)[0]) if now_price['time'] == db_price['time'] and same < 4 * 60: now_price['no'] = db_price['no'] redis.zrem("fx", json.dumps(db_price)) chart = {} chart[json.dumps(now_price)] = last_no redis.zadd("fx", chart) same += 1 elif now_price['time'] != db_price['time']: now_price['no'] = db_price['no'] + 1 chart = {} chart[json.dumps(now_price)] = last_no redis.zadd("fx", chart) print("rate : %s %d %d %6.3f" % (loc.astimezone(JST), now_price['no'], now_price['time'],
def return_new_ten(redis): last_id = int(redis.zrange("nArticles", -1, -1)[0]) return redis.zrange("nArticles", last_id - 9, last_id)
def partitions(): redis = get_redis() start = request.args.get('start') end = request.args.get('end') key = current_app.config['KEY_PREFIX'] + 'PT' + str( current_app.config['PARTITION']) + 'M' first = redis.zrange(key, 0, 0) last = redis.zrevrange(key, 0, 0) prefix_len = len(current_app.config['KEY_PREFIX']) if len(first) == 0: return jsonify({}) first = first[0].decode('utf-8') first_datetime = first[prefix_len:first.rfind('PT')] last = last[0].decode('utf-8') last_datetime = last[prefix_len:last.rfind('PT')] partition_info = { 'duration': 'PT' + str(current_app.config['PARTITION']) + 'M', 'first': { 'at': first_datetime, 'partition': first }, 'last': { 'at': last_datetime, 'partition': last } } if start is None and end is None: return jsonify(partition_info) if start is None: start = first_datetime if start.find('T') < 0: start += 'T00:00:00' if end is not None and end.find('T') < 0: end += 'T23:59:59' start = datetime.fromisoformat(start) if end is None: timestamp = datetime.utcnow() partition_no = timestamp.minute // current_app.config['PARTITION'] end = datetime(timestamp.year, timestamp.month, timestamp.day, timestamp.hour, partition_no * current_app.config['PARTITION'], tzinfo=timestamp.tzinfo) else: end = datetime.fromisoformat(end) start_score = datetime_score(start) end_score = datetime_score(end) partitions = list( map(lambda v: v.decode('utf-8')[prefix_len:], redis.zrangebyscore(key, start_score, end_score))) partition_info['partitions'] = partitions return jsonify(partition_info)
def _get_artist(self): try: return redis.zrange(self.turns_key, 0, 0)[0] except IndexError: return None
import redis import threading import requests endpoint = "http://127.0.0.1:8000" redis = redis.Redis(host="localhost", port = 6900) def response_ser(server, data): resp = requests.get(server, data) print(f'{resp} is the server response for {data} being pushed') while True: try: data = redis.zrange('queue',-1,-1) if len(data): redis.zrem('queue',data[0]) t = threading.Thread(target = response_ser, args = [endpoint, data[0]]) t.start() except: print('ERROR!') pass ~ ~ ~
def get_k_oldest(k): ids = redis.zrange(Proxy._get_sorted_set_key(), 0, k) return Proxy.get_by_ids(ids)
PREFIX = '' redis = redis.Redis( host=IP, port=PORT, password=PASSWORD, db=DATABASE, socket_timeout=None, ssl_ca_certs= '/home/dev/PycharmProjects/CommonExploits/db_dumpers/ca-certificate.crt') for key in redis.scan_iter(match=f'{PREFIX}*'): print(key, flush=True) key_type = redis.type(key) try: if key_type == b'string': result = redis.get(key) elif key_type == b'set': result = redis.smembers(key) elif key_type == b'hash': result = redis.hgetall(key) elif key_type == b'list': result = redis.lrange(key, 0, -1) elif key_type == b'zset': result = redis.zrange(key, 0, -1) else: result = redis.get(key) print(result, flush=True) except: continue
import redis redis = redis.Redis() redis.flushall() FEM = "female_names_set" with open("female-names.txt", "r") as f: for line in f: redis.zadd(FEM, {line.rstrip(): 0}) print("Finished loading the names") print(redis.zrange(FEM, 4500, 4510)) print("Searching that start with susann") for tup in redis.zscan_iter(FEM, "susann*"): print(tup[0], end=',') print() while True: name = input("Search for ('Enter' for quit): ") if name == "": break for tup in redis.zscan_iter(FEM, name + "*"): print(tup[0]) ## b) redis.flushall() with open("nomes-registados-2018.csv", "r") as f: for line in f: name, gender, num = line.rstrip().split(",") redis.zadd(FEM, {name: num})
# +--------------------------------------------------------------+ # | SCRIPT | # +--------------------------------------------------------------+ audit_number = 50 missing_entries = 0 bad_entries = 0 corrupted_entries = 0 # +--------------------------------------------------------------+ # Snapshot | # +--------------------------------------------------------------+ time_begin = redis.time() # Get metablock from Redis all_metadata_metablock_entries = redis.zrange("block_index", 0, -1) all_decoded_metablock_metadata = convert_redis_index( all_metadata_metablock_entries) # Get metablock from Redis all_metadata_metadoc_entries = redis.zrange("file_index", 0, -1) all_decoded_metadoc_metadata = convert_redis_index( all_metadata_metadoc_entries) # Get number metablock in blockchain nb_metablock = store_var_contract.functions.getNumberMetablock().call() # Get number metadoc in blockchain nb_metadoc = store_var_contract.functions.getNumberMetadoc().call() print("\n") print("*********************************************************************") print("AUDIT CONFIGURATION") print("*********************************************************************")
if arguments.zadd: if arguments.key: if arguments.score: if arguments.member: # redis.zadd("key",{"value":score}) syntax of zadd for newer update of redis----------------- redis.zadd(arguments.key, {arguments.member: arguments.score}) print("zadd", arguments.key, arguments.score, arguments.member) else: print("provide member for zadd") else: print("provide score for zadd") else: print("provide the key for zadd") if arguments.zrange: if arguments.key: data = redis.zrange(arguments.key, 0, -1) print(data[:]) else: print("provide the key for zrange") if arguments.zrank: if arguments.key: if arguments.member: data = redis.zrank(arguments.key, arguments.member) print(data) else: print("provide member for zrank") else: print("provide the key for zrank")
def index_clear_range(start=None, end=None): zrange = redis.zrange('index', start, end) redis.zremrangebyrank('index', start, end) return zrange
#https://developer.redis.com/develop/python/ import redis redis = redis.Redis(host='localhost', port='6379') redis.set('mykey', 'Hello from Python!') value = redis.get('mykey') print(value) redis.zadd('vehicles', {'car': 0}) redis.zadd('vehicles', {'bike': 0}) vehicles = redis.zrange('vehicles', 0, -1) print(vehicles)