Python StrictRedis.hkeys方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hkeys [as 别名]
class RedisStorage(BaseSharedStorage):
    def __init__(self, db_num):
        self._redis = StrictRedis(db=db_num)

    def save(self, filename, key, data):
        self._purge_duplicates(filename)
        self._redis.hset(filename, key, data)

    def load(self, filename):
        redis_keys = self._redis.hkeys(filename)
        key = redis_keys[0]  # Should never be more than one key
        data = self._redis.hget(filename, key)
        return key, data

    def _purge_duplicates(self, dict_key):
        """Remove identical files from server to be replaced by new files."""
        keys = self._redis.hkeys(dict_key)
        for key in keys:
            self._redis.hdel(dict_key, key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hkeys [as 别名]
class RedisDict(MutableMapping):
    """ RedisDict - a dictionary-like interface for ``redis`` key-stores
    """
    def __init__(self, namespace, collection_name='redis_dict_data',
                 connection=None):
        """
        The actual key name on the redis server will be
        ``namespace``:``collection_name``

        In order to deal with how redis stores data/keys,
        everything, i.e. keys and data, must be pickled.

        :param namespace: namespace to use
        :param collection_name: name of the hash map stored in redis
                                (default: redis_dict_data)
        :param connection: ``redis.StrictRedis`` instance.
                           If it's ``None`` (default), a new connection with
                           default options will be created

        """
        if connection is not None:
            self.connection = connection
        else:
            self.connection = Redis()
        self._self_key = ':'.join([namespace, collection_name])

    def __getitem__(self, key):
        result = self.connection.hget(self._self_key, pickle.dumps(key))
        if result is None:
            raise KeyError
        return pickle.loads(bytes(result))

    def __setitem__(self, key, item):
        self.connection.hset(self._self_key, pickle.dumps(key),
                             pickle.dumps(item))

    def __delitem__(self, key):
        if not self.connection.hdel(self._self_key, pickle.dumps(key)):
            raise KeyError

    def __len__(self):
        return self.connection.hlen(self._self_key)

    def __iter__(self):
        for v in self.connection.hkeys(self._self_key):
            yield pickle.loads(bytes(v))

    def clear(self):
        self.connection.delete(self._self_key)

    def __str__(self):
        return str(dict(self.items()))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hkeys [as 别名]
def delete(obj, key=None):
    """
    Delete a single key if specified, or all namespace if key is none
    :param obj: settings object
    :param key: key to delete from store location
    :return: None
    """
    client = StrictRedis(**obj.REDIS_FOR_DYNACONF)
    holder = "DYNACONF_%s" % obj.DYNACONF_NAMESPACE
    if key:
        client.hdel(holder.upper(), key.upper())
        obj.unset(key)
    else:
        keys = client.hkeys(holder.upper())
        client.delete(holder.upper())
        obj.unset_all(keys)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hkeys [as 别名]

#.........这里部分代码省略.........
			params = []
			if len(args) < arg_num:
				self.help(arg)
				return
			elif arg_num == 0:
				params = []
			elif arg_num == -1:
				params = [args]
			else:
				params = args[:arg_num]
			if self.commands[arg].get("username", False):
				self.commands[arg]["method"](username, *params)
			else:
				self.commands[arg]["method"](*params)
		elif arg in self.commands.keys():
			self.help(arg)

	def purge(self, username):
		if username == "zachzor":
			self.redis_server.delete("challs")
			self.send_message("All challenges removed")

	def get(self, challenge_name):
		if challenge_name[0] == '#':
			try:
				challenge_number = int(challenge_name[1:])
			except ValueError:
				self.send_message("%s is not a valid challenge id" % challenge_name)
				return
			if self.redis_server.hlen("challs") <= challenge_number or challenge_number < 0:
				self.send_message("%s is not a valid challenge id" % challenge_name)
				return
			else:
				name = [(i, s) for i, s in enumerate(self.redis_server.hkeys("challs"))][challenge_number][1]
				try:
					gist = self.create_gist(name, pickle.loads(self.redis_server.hget("challs", name)))
					self.send_message("%s" % gist)
				except GistException:
					self.send_message("Unable to create gist")
		else:
			if not self.redis_server.hexists("challs", challenge_name):
				self.send_message("%s is not a valid challenge name" % challenge_name)
				return
			else:
				try:
					gist = self.create_gist(challenge_name, pickle.loads(self.redis_server.hget("challs", challenge_name)))
					self.send_message("%s" % gist)
				except GistException:
					self.send_message("Unable to create gist")

	def farts(self):
		self.send_message(" ".join(list(["pfffttt"] * randint(1, 7))))

	def add(self, username, args):
		if len(args) < 2:
			self.help("add")
			return
		challenge_name, description = args[0], args[1:]
		new_info = InfoMessage(username, datetime.now().strftime("%m-%d-%Y %H:%M:%S"), " ".join(description))
		if self.redis_server.hget("challs", challenge_name) == None:
			self.redis_server.hset("challs", challenge_name, pickle.dumps([new_info]))
		else:
			old = pickle.loads(self.redis_server.hget("challs", challenge_name))
			old.append(new_info)
			self.redis_server.hset("challs", challenge_name, pickle.dumps(old))
		self.send_message("Added!")