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 _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 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 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_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 _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)
def _get_artist(self):
try:
return redis.zrange(self.turns_key, 0, 0)[0]
except IndexError:
return None
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)
