本文整理汇总了Python中redis.StrictRedis.smembers方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.smembers方法的具体用法?Python StrictRedis.smembers怎么用?Python StrictRedis.smembers使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.smembers方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: MispRedisConnector
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class MispRedisConnector(object):
def __init__(self):
self.r = StrictRedis(unix_socket_path=redis_socket)
def search(self, authkey, values=None, hash_values=None, return_eid=False, quiet=False):
if isinstance(values, list):
hash_values = [SHA256.new(v.lower()).hexdigest() for v in values]
elif values:
hash_values = [SHA256.new(values.lower()).hexdigest()]
elif not isinstance(hash_values, list):
hash_values = [hash_values]
if not hash_values:
raise Exception('No value to search.')
org = self.__get_org_by_auth(authkey)
if not org:
raise Exception('Invalid authkey')
if quiet:
return [(self.r.exists(h) or self.r.exists(org + ':' + h)) for h in hash_values]
uuid_by_hashes = [self.r.smembers(h).union(self.r.smembers(org + ':' + h)) for h in hash_values]
if not return_eid:
to_return = uuid_by_hashes
else:
to_return = []
for h in uuid_by_hashes:
to_return.append([self.r.hget('uuid_id', uuid) for uuid in h])
return to_return
def __get_org_by_auth(self, authkey):
return self.r.get(authkey)
示例2: Redis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class Redis(BaseDB):
def __init__(self, host='localhost', port=6379, db=0):
super().__init__()
self.db = StrictRedis(host=host, port=port, db=db)
self.available = False
def push_to_available(self, user_id):
self.db.sadd('available', user_id) # Add user to awaiting queue
self.check_available()
def pop_first_available(self, self_user_id):
while not self.available:
threading.Event().wait() # Prevent busy wait and CPU load
res = [int(x) for x in self.db.smembers('available')] # Get all available possible interlocutors
shuffle(res) # Randomize queue
if self_user_id in res: # User may be listed too
res.remove(self_user_id) # If so, remove him
res = res.pop() # Get random interlocutor
self.check_available()
return res
def remove(self, user_id):
self.db.srem('available', user_id)
self.check_available()
def check_available(self):
self.available = True if self.db.scard('available') - 1 > 0 else False # If there are more than 1 user in queue
示例3: test_queue_adopt_producer_step
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def test_queue_adopt_producer_step():
("Queue#adopt_producer should take a step and know about its id and")
# Given a dummy manager
manager = Node()
# Given a Queue with maximum size of 10
queue = Queue("test-queue", maxsize=10)
q1 = Queue("name1")
q2 = Queue("name2")
# And a running step (so it gains a thread id)
step = DummyStep(q1, q2, manager)
step.start()
# When that queue adopts the step as a producer
consumers, producers = queue.adopt_producer(step)
# And the redis key should contain the step id
hostname = socket.gethostname()
pid = os.getpid()
tid = step.ident
value = "{hostname}|{pid}|{tid}|tests.functional.test_queue.DummyStep|lineup.framework.Node".format(**locals())
redis = StrictRedis()
members = redis.smembers("lineup:test-queue:producers")
members.should.contain(value)
queue.deactivate()
q1.deactivate()
q2.deactivate()
示例4: check_redis_host
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def check_redis_host(host, port=6379):
action("Check Redis on {}".format(host))
action("...")
try:
r = StrictRedis(host, port)
workers = r.smembers("zmon:metrics")
ok()
return r, workers
except Exception as e:
error(e)
示例5: Storage
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class Storage(object):
def __init__(self, host=None, port=None, *args, **kwargs):
if host is None:
host = os.environ.get('REDIS_HOST', 'localhost')
if port is None:
port = os.environ.get('REDIS_PORT', '6379')
self.redis = StrictRedis(host, port, *args, **kwargs)
def get_labels(self):
return [x.decode('utf-8') for x in self.redis.smembers('labels')]
def get_images(self, label):
return self.redis.smembers(label)
def get_repr_image_for_labels(self, labels):
if not labels:
return {}
keys = [u'repr_img:{}'.format(label) for label in labels]
return dict(zip(labels, self.redis.mget(*keys)))
示例6: ProxyCheckSpider
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class ProxyCheckSpider(Spider):
''' Spider to crawl free proxy servers for intern
'''
name = 'proxy_check'
def __init__(self, mode='prod', *args, **kwargs):
if mode == 'prod':
LOCAL_CONFIG_YAML = './hq-proxies.yml'
elif mode == 'test':
LOCAL_CONFIG_YAML = './hq-proxies.test.yml'
with open(LOCAL_CONFIG_YAML, 'r', encoding='utf-8') as f:
LOCAL_CONFIG = yaml.load(f)
self.redis_db = StrictRedis(
host=LOCAL_CONFIG['REDIS_HOST'],
port=LOCAL_CONFIG['REDIS_PORT'],
password=LOCAL_CONFIG['REDIS_PASSWORD'],
db=LOCAL_CONFIG['REDIS_DB']
)
self.validator_pool = set([])
for validator in LOCAL_CONFIG['PROXY_VALIDATORS']:
self.validator_pool.add((validator['url'], validator['startstring']))
self.PROXY_COUNT = LOCAL_CONFIG['PROXY_COUNT']
self.PROXY_SET = LOCAL_CONFIG['PROXY_SET']
def start_requests(self):
logger.info('测试代理池内代理质量...')
self.redis_db.set(self.PROXY_COUNT, self.redis_db.scard(self.PROXY_SET))
for proxy in self.redis_db.smembers(self.PROXY_SET):
proxy = proxy.decode('utf-8')
vaurl, vastart = random.choice(list(self.validator_pool))
yield Request(url=vaurl, meta={'proxy': proxy, 'startstring': vastart}, callback=self.checkin, dont_filter=True)
def checkin(self, response):
res = response.body_as_unicode()
if 'startstring' in response.meta and res.startswith(response.meta['startstring']):
proxy = response.meta['proxy']
self.redis_db.sadd(self.PROXY_SET, proxy)
logger.info('可用代理+1 %s' % proxy)
yield None
else:
proxy = response.url if 'proxy' not in response.meta else response.meta['proxy']
self.redis_db.srem(self.PROXY_SET, proxy)
logger.info('无效代理 %s' % proxy)
yield None
def closed(self, reason):
pcount = self.redis_db.scard(self.PROXY_SET)
logger.info('代理池测试完成,有效代理数: %s' % pcount)
self.redis_db.set(self.PROXY_COUNT, pcount)
示例7: search
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def search(request):
if request.get('value'):
hash_value = SHA.new(request.get('value')).hexdigest()
else:
hash_value = request.get('hash_value')
if hash_value is None:
return json.dumps({})
r = StrictRedis(unix_socket_path=redis_socket)
known_uuids = r.smembers(hash_value)
to_return = {'known': (len(known_uuids) != 0)}
if not request.get('quiet'):
to_return['uuids'] = known_uuids
return to_return
示例8: PECorrelator
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class PECorrelator(object):
def __init__(self):
self.r = StrictRedis(unix_socket_path=redis_socket, decode_responses=True)
def get_all_samples(self):
return self.r.smembers("hashes_sha256")
def get_all_hashes(self, sha256):
return [sha256] + list(self.r.hmget(sha256, ["sha1", "md5"]))
def get_sample_info(self, sha256):
return self.r.hgetall(sha256)
def get_timestamps_iso(self, num=-1):
return [
(datetime.datetime.fromtimestamp(ts).isoformat(), val)
for ts, val in self.r.zrevrange("timestamps", 0, num, withscores=True)
]
def get_timestamps(self, num=-1):
return self.r.zrevrange("timestamps", 0, num, withscores=True)
def get_samples_timestamp(self, timestamp):
return self.r.smembers("timestamp:{}".format(timestamp))
def get_imphashs(self, num=-1):
return self.r.zrevrange("imphashs", 0, num, withscores=True)
def get_samples_imphash(self, imphash):
return self.r.smembers("imphash:{}".format(imphash))
def get_entrypoints(self, num=-1):
return self.r.zrevrange("entrypoints", 0, num, withscores=True)
def get_samples_entrypoint(self, entrypoint):
return self.r.smembers("entrypoint:{}".format(entrypoint))
def get_secnumbers(self, num=-1):
return self.r.zrevrange("secnumbers", 0, num, withscores=True)
def get_samples_secnumber(self, secnumber):
return self.r.smembers("secnumber:{}".format(secnumber))
def get_originalfilenames(self, num=-1):
return self.r.zrevrange("originalfilenames", 0, num, withscores=True)
def get_samples_originalfilename(self, originalfilename):
return self.r.smembers("originalfilename:{}".format(originalfilename))
def get_sample_secnames(self, sha256):
return self.r.smembers("{}:secnames".format(sha256))
示例9: Persist
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class Persist(object):
""" Sequential writer for Carbon server.
The story is simple, fetch data from redis, write them, wait, loop.
This code is supervised by Carbon daemon.
"""
def __init__(self, path="/tmp/"):
self.redis = Redis()
self.path = path
self.dirs = set()
self.redis.sadd(METRICS, METRIC_POINTS, METRIC_WRITE)
def metric(self, name, value):
"Add some metrics : make your own dogfood, just before lunch."
timestamp = time.time()
serialized = struct.pack('!ff', timestamp, value)
pipe = self.redis.pipeline()
pipe.zadd(name, timestamp, serialized)
pipe.publish(name, serialized)
pipe.execute()
def run(self):
while True:
before = time.time()
self.handle()
after = time.time()
self.metric(METRIC_WRITE, (after - before) * 1000)
time.sleep(PERIOD - int(before) + int(after))
def handle(self):
points = 0
for metric in self.redis.smembers(METRICS):
values = self.redis.zrange(metric, 0, -1)
points += len(values)
f = target_to_path(self.path, metric)
d = os.path.dirname(f)
if d not in self.dirs:
if not os.path.isdir(d):
os.makedirs(d)
self.dirs.add(d)
if not os.path.exists(f):
whisper.create(f, [(10, 1000)]) # [FIXME] hardcoded values
whisper.update_many(f, [struct.unpack('!ff', a) for a in values])
if len(values):
self.redis.zrem(metric, *values)
self.metric(METRIC_POINTS, points)
示例10: ginfo
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def ginfo(request):
print(str(request.user)+' requested groupinfo')
rd = StrictRedis()
pref = settings.MY_PREFIX
groupinfo = []
response = {}
if rd.exists(pref+":groups"):
# there is atleast 1 group already created
groupnames = rd.smembers(pref+":groups")
# groupnames is a set
for groupname in groupnames:
groupdict = rd.hgetall(pref+":"+groupname+":hash")
groupinfo.append(groupdict)
#print groupdict
# time to serialize!
response['group_list'] = groupinfo
response.update( {"success":True, "group_count":len(groupinfo)})
#print response
return JsonResponse(response)
示例11: search_db
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def search_db(name):
r = StrictRedis(host='localhost', port=6379, db=1)
# Redisから取得
artist_name_list = r.keys("*_" + name)
if artist_name_list:
for artist_name in artist_name_list:
_id = artist_name.split("_")[:1][0]
_name = "".join(artist_name.split("_")[1:])
print u"ID:{} アーティスト名:{}".format(_id, _name)
for tag in r.smembers(artist_name):
tag_cnt = tag.split("_")[:1][0]
tag_name = "".join(tag.split("_")[1:])
print u"タグ:{} 被タグ数:{}".format(tag_name, tag_cnt)
else:
print u"データベースに存在しません"
示例12: MetricsExplorer
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class MetricsExplorer(Explorer):
def __init__(self, config: Configuration):
super().__init__('RedisCassandra')
redis_host = config.get('redis.host')
redis_port = config.get('redis.port')
redis_pass = config.get('redis.password')
#TODO: change to Sentinel so we can handle multiple hosts
self.redis_conn = StrictRedis(host=redis_host, port=redis_port, password=redis_pass)
self.cache = get_cache()
def get_template(self):
return 'explorers/metrics.html'
def get_table_data(self):
ret = self.cache.get('_tname')
if ret is not None:
return ret
tag_names = self.redis_conn.smembers('_tname')
tag_names = [t.decode() for t in tag_names]
pipeline = self.redis_conn.pipeline() # setup a pipeline
for tag_name in tag_names:
# {'tag': name.decode()}
pipeline.smembers('_t|%s'%tag_name)
values = pipeline.execute()
ret = []
for i in range(len(tag_names)):
ret.append({'tag': tag_names[i], 'values': [v.decode() for v in values[i]]})
self.cache.set('_tname', ret)
return ret
示例13: Redis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class Redis(Backend):
"""Default backend for MimicDB. Initiated with identical parameters
as ``redis.StrictRedis``.
:param args \*args, \**kwargs: StrictRedis.__init__() parameters
.. code-block:: python
from mimicdb.backends.default import Redis
redis = Redis(host='localhost', port=6379, db=0)
"""
def __init__(self, *args, **kwargs):
self._redis = StrictRedis(*args, **kwargs)
def keys(self, pattern='*'):
return self._redis.keys(pattern)
def delete(self, *names):
return self._redis.delete(*names)
def sadd(self, name, *values):
return self._redis.sadd(name, *values)
def srem(self, name, *values):
return self._redis.srem(name, *values)
def sismember(self, name, value):
return self._redis.sismember(name, value)
def smembers(self, name):
return self._redis.smembers(name)
def hmset(self, name, mapping):
return self._redis.hmset(name, mapping)
def hgetall(self, name):
return self._redis.hgetall(name)
示例14: Redis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class Redis():
INVITE_EXPIRATION = 300
def __init__(self, host='pulsing.jhk.org', port=6379, password='wsad', db=0, **kwargs):
super().__init__()
self.logger = logging.getLogger(__name__)
self.__client = StrictRedis(host=host, port=port, password=password, db=0, **kwargs)
def storeInvitation(self, to_user_id, from_user_id, invitation_id, invitationType):
expiration = datetime.utcnow() + timedelta(seconds=Redis.INVITE_EXPIRATION)
self.__client.setex(invitation_id, '1', Redis.INVITE_EXPIRATION)
self.__client.sadd('INVITATIONS_'+to_user_id,
json.dumps(getInvitation(from_user_id, invitationType, invitation_id, expiration.timestamp() * 1000.0)))
def removeInvitation(self, user_id, invitation_id):
s_invitations = self.__client.smembers('INVITATIONS_'+user_id)
self.logger.debug('removeInvitation fetched - %s ', s_invitations)
invitations = json.loads(s_invitations)
self.logger.debug('removeInvitation parsed - %s ', invitations)
invitation = [invite for invite in invitations if (invite['invitationId'] == invitation_id)]
self.__client.delete(invitation_id)
return invitation
@property
def client(self):
return self.__client
def __eq__(self, other):
return self.__client == other.__client
def __str__(self):
return self.__client.__str__()
def __hash__(self):
return self.__client.__hash__()
示例15: TestPredis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class TestPredis(object):
def setUp(self):
self.redis = StrictRedis(db=9)
self.predis = Predis(prefix="test", db=9)
def tearDown(self):
self.redis.flushdb()
def test_set(self):
self.predis.set("foo", "bar")
assert self.redis.get("test:foo") == "bar"
def test_get(self):
self.redis.set("test:foo", "bar")
assert self.predis.get("foo") == "bar"
def test_sunionstore(self):
self.redis.sadd("test:foo", "bar")
self.redis.sadd("test:boo", "bat")
self.redis.sadd("test:goo", "bak")
self.predis.sunionstore("blah", ["foo", "boo"], "goo")
assert self.redis.smembers("test:blah") == set(["bar", "bat", "bak"])