Python redis.StrictRedis() Examples

def _setup_redis(self):
        """Returns a Redis Client"""
        if not self.closed:
            try:
                self.logger.debug("Creating redis connection to host " +
                                  str(self.settings['REDIS_HOST']))
                self.redis_conn = redis.StrictRedis(host=self.settings['REDIS_HOST'],
                                              port=self.settings['REDIS_PORT'],
                                              db=self.settings['REDIS_DB'])
                self.redis_conn.info()
                self.redis_connected = True
                self.logger.info("Successfully connected to redis")
            except KeyError as e:
                self.logger.error('Missing setting named ' + str(e),
                                   {'ex': traceback.format_exc()})
            except:
                self.logger.error("Couldn't initialize redis client.",
                                   {'ex': traceback.format_exc()})
                raise 

def __init__(self, actor_no, env, policy_net, vis, hostname='localhost',
                 batch_size=50, nstep_return=3, gamma=0.999,
                 clip=lambda x: min(max(-1.0, x), 1.0),
                 target_update=200, num_total_actors=4,
                 device=torch.device("cuda" if torch.cuda.is_available() else "cpu")):
        self._env = env
        self._actor_no = actor_no
        self._name = "actor_" + str(actor_no)
        self._vis = vis
        self._batch_size = batch_size
        self._nstep_return = nstep_return
        self._gamma = gamma
        self._clip = clip
        self._target_update = target_update
        self._num_total_actors = num_total_actors
        self._policy_net = policy_net
        self._policy_net.eval()
        self._device = device
        self._win1 = self._vis.image(utils.preprocess(self._env.env._get_image()))
        self._win2 = self._vis.line(X=np.array([0]), Y=np.array([0.0]),
                                    opts=dict(title='Score %s' % self._name))
        self._local_memory = replay_memory.ReplayMemory(1000)
        self._connect = redis.StrictRedis(host=hostname) 

def reset_cached_search_results(project):
    try:
        redis_client = redis.StrictRedis(host=REDIS_SERVICE_HOSTNAME, socket_connect_timeout=3)
        keys_to_delete = []
        if project:
            result_guids = [res.guid for res in VariantSearchResults.objects.filter(families__project=project)]
            for guid in result_guids:
                keys_to_delete += redis_client.keys(pattern='search_results__{}*'.format(guid))
        else:
            keys_to_delete = redis_client.keys(pattern='search_results__*')
        if keys_to_delete:
            redis_client.delete(*keys_to_delete)
            logger.info('Reset {} cached results'.format(len(keys_to_delete)))
        else:
            logger.info('No cached results to reset')
    except Exception as e:
        logger.error("Unable to reset cached search results: {}".format(e)) 

def __init__(self, policy_net, target_net, optimizer,
                 vis, replay_size=30000, hostname='localhost',
                 beta_decay=1000000,
                 use_memory_compress=False):
        self._vis = vis
        self._policy_net = policy_net
        self._target_net = target_net
        self._target_net.load_state_dict(self._policy_net.state_dict())
        self._target_net.eval()
        self._beta_decay = beta_decay
        self._connect = redis.StrictRedis(host=hostname)
        self._connect.delete('params')
        self._optimizer = optimizer
        self._win = self._vis.line(X=np.array([0]), Y=np.array([0]),
                                   opts=dict(title='Memory size'))
        self._win2 = self._vis.line(X=np.array([0]), Y=np.array([0]),
                                    opts=dict(title='Q loss'))
        self._memory = replay.Replay(replay_size, self._connect,
                                     use_compress=use_memory_compress)
        self._memory.start() 

def __init__(self, name, host='localhost', port=6379, db=0,
                 maxsize=0, lazy_limit=True, password=None, cluster_nodes=None):
        """
        Constructor for RedisQueue

        maxsize:    an integer that sets the upperbound limit on the number of
                    items that can be placed in the queue.
        lazy_limit: redis queue is shared via instance, a lazy size limit is used
                    for better performance.
        """
        self.name = name
        if(cluster_nodes is not None):
            from rediscluster import StrictRedisCluster
            self.redis = StrictRedisCluster(startup_nodes=cluster_nodes)
        else:
            self.redis = redis.StrictRedis(host=host, port=port, db=db, password=password)
        self.maxsize = maxsize
        self.lazy_limit = lazy_limit
        self.last_qsize = 0 

def setup_once():
        # type: () -> None
        import redis

        patch_redis_client(redis.StrictRedis)

        try:
            import rb.clients  # type: ignore
        except ImportError:
            pass
        else:
            patch_redis_client(rb.clients.FanoutClient)
            patch_redis_client(rb.clients.MappingClient)
            patch_redis_client(rb.clients.RoutingClient)

        try:
            _patch_rediscluster()
        except Exception:
            logger.exception("Error occured while patching `rediscluster` library") 

def __init__(self, io_loop: asyncio.AbstractEventLoop = None):
        super().__init__()
        self.io_loop = io_loop or asyncio.get_event_loop()
        self.sub_client = self.io_loop.run_until_complete(
                aioredis.create_redis((config.get('REDIS', 'host', fallback='localhost'),
                                       config.getint('REDIS', 'port', fallback=6379)),
                                      db=config.getint('REDIS', 'db', fallback=1)))
        self.redis_client = redis.StrictRedis(
            host=config.get('REDIS', 'host', fallback='localhost'),
            db=config.getint('REDIS', 'db', fallback=1), decode_responses=True)
        self.initialized = False
        self.sub_tasks = list()
        self.sub_channels = list()
        self.channel_router = dict()
        self.crontab_router = defaultdict(dict)
        self.datetime = None
        self.time = None
        self.loop_time = None 

def init():
    """
    Initialize key value store that will be used for the event publishing.
    That way the main API takes advantage of Redis pub/sub capabilities to push
    events to the event stream API.
    """
    global socketio

    try:
        publisher_store = redis.StrictRedis(
            host=host, port=port, db=redis_db, decode_responses=True
        )
        publisher_store.get("test")
        socketio = SocketIO(message_queue=redis_url)
    except redis.ConnectionError:
        pass

    return socketio 

def get_cache(cls, **kwargs):
        client = redis.StrictRedis('127.0.0.1', 6379)
        return RedisLRU(client, clear_on_exit=True, **kwargs) 

def test_uw(self):
        config = {}
        chassis = mock.Mock()

        chassis.request_sub_channel.return_value = None
        ochannel = mock.Mock()
        chassis.request_pub_channel.return_value = ochannel
        chassis.request_rpc_channel.return_value = None
        rpcmock = mock.Mock()
        rpcmock.get.return_value = {'error': None, 'result': 'OK'}
        chassis.send_rpc.return_value = rpcmock

        b = minemeld.ft.redis.RedisSet(FTNAME, chassis, config)

        inputs = ['a', 'b', 'c']
        output = False

        b.connect(inputs, output)
        b.mgmtbus_initialize()

        b.start()
        time.sleep(1)

        SR = redis.StrictRedis()

        b.filtered_update('a', indicator='testi', value={'test': 'v'})
        sm = SR.zrange(FTNAME, 0, -1)
        self.assertEqual(len(sm), 1)
        self.assertIn('testi', sm)

        b.filtered_withdraw('a', indicator='testi')
        sm = SR.zrange(FTNAME, 0, -1)
        self.assertEqual(len(sm), 0)

        b.stop()
        self.assertNotEqual(b.SR, None) 

def get_log_redis_client():
    return redis.StrictRedis(**conf.LOG_REDIS_CONFIG) 

def tearDown(self):
        SR = redis.StrictRedis()
        SR.delete(FTNAME) 

def municipality_data(request):
    # r = redis.StrictRedis(host=settings.REDIS_HOST, port=6379, db=3)
    # data = r.hgetall("municipality")
    data = generate_municipality_data()
    return Response(data.values()) 

def init_app(app, redis_url):
    redis_cp = redis.ConnectionPool.from_url(
        redis_url,
        max_connections=int(os.environ.get('REDIS_SESSIONS_MAX_CONNECTIONS', 20))
    )

    app.session_interface = RedisSessionInterface(
        redis_=redis.StrictRedis(connection_pool=redis_cp)
    )
    app.config.update(
        SESSION_COOKIE_NAME='mm-session',
        SESSION_COOKIE_SECURE=True
    ) 

def __init__(self, redis_=None, prefix='mm-session:'):
        if redis_ is None:
            redis_ = redis.StrictRedis()
        self.redis = redis_
        self.prefix = prefix
        self.expirtaion_delta = timedelta(
            minutes=int(os.environ.get(
                SESSION_EXPIRATION_ENV,
                DEFAULT_SESSION_EXPIRATION
            ))
        ) 

def __init__(self, domain, mock=False, host='localhost',
                 port=6379, db=0, password=None):

        if mock:
            import fakeredis
            self.red = fakeredis.FakeStrictRedis()
        else:  # pragma: no cover
            import redis
            self.red = redis.StrictRedis(host=host, port=port, db=db,
                                         password=password)
        super(RedisTrackerStore, self).__init__(domain) 

def _init(self, server, params):
        super(RedisClient, self).__init__(params)
        self._server = server
        self._params = params

        unix_socket_path = None
        if ':' in self.server:
            host, port = self.server.rsplit(':', 1)
            try:
                port = int(port)
            except (ValueError, TypeError):
                raise ConfigError("port value must be an integer")
        else:
            host, port = None, None
            unix_socket_path = self.server

        kwargs = {
            'db': self.db,
            'password': self.password,
            'host': host,
            'port': port,
            'unix_socket_path': unix_socket_path,
        }

        connection_pool = pool.get_connection_pool(
            parser_class=self.parser_class,
            connection_pool_class=self.connection_pool_class,
            connection_pool_class_kwargs=self.connection_pool_class_kwargs,
            **kwargs
        )
        self._client = redis.StrictRedis(
            connection_pool=connection_pool,
            **kwargs
        ) 

def __init__(self):
        self.client = redis.StrictRedis(
            connection_pool=conn_pool, socket_timeout=RC.SOCKET_TIMEOUT) 

def __init__(self, connection_pool):
        self.SR = redis.StrictRedis(connection_pool=connection_pool)
        self.running_jobs = defaultdict(dict) 

def get_report_redis_client():
    return redis.StrictRedis(**conf.REPORT_REDIS_CONFIG) 

def connect(self):
        subscribers_key = '{}:subscribers'.format(self.prefix)

        SR = redis.StrictRedis(
            connection_pool=self.connection_pool
        )

        self.sub_number = SR.rpush(
            subscribers_key,
            0
        )
        self.sub_number -= 1
        LOG.debug('Sub Number {} on {}'.format(self.sub_number, subscribers_key)) 

def get_config_redis_client():
    return redis.StrictRedis(**conf.REDIS_CONFIG) 

def __init__(self, host=configs["redis_host"], port=configs["redis_port"], password=configs["redis_password"]):
        self.rc = redis.StrictRedis(host=host, port=port, password=password) 

def __init__(self, host=configs["redis_host"], port=configs["redis_port"]):
        self.rc = redis.StrictRedis(host=host, port=port)
        print(host, port) 

def redis_populate(filepath):
    """Function to populate keys in Redis Server"""
    configs = load_config(filepath)
    client = redis.StrictRedis(host=configs["redis_host"], port=configs["redis_port"])
    for i in range(100000):
        key='key'+str(i)
        value='value'+str(i)
        client.set(key,value)
        print(key,value) 

def __init__(self, channel='gw', **settings):
        ### 订阅日志使用默认redis 如果有需求 请自行修改配置
        redis_info = settings.get(const.REDIS_CONFIG_ITEM, None).get(const.DEFAULT_RD_KEY, None)
        if not redis_info:
            exit('not redis')
        self.pool = redis.ConnectionPool(host=redis_info.get(const.RD_HOST_KEY),
                                         port=redis_info.get(const.RD_PORT_KEY, 6379),
                                         db=redis_info.get(const.RD_DB_KEY, 0),
                                         password=redis_info.get(const.RD_PASSWORD_KEY, None))
        self.conn = redis.StrictRedis(connection_pool=self.pool)
        self.channel = channel  # 定义频道名称
        self.__settings = settings 

def __init__(self,
                 client: redis.StrictRedis,
                 max_size=2 ** 20,
                 default_ttl=15 * 60,
                 key_prefix='RedisLRU',
                 clear_on_exit=False,
                 exclude_values=None):
        self.client = client
        self.max_size = max_size
        self.key_prefix = key_prefix
        self.default_ttl = default_ttl
        self.exclude_values = exclude_values if type(exclude_values) is set else set()

        if clear_on_exit:
            atexit.register(self.clear_all_cache) 

def __init__(self):
        self.redis_connection = redis.StrictRedis()
        self.key = "score_1" 

def __init__(self):
        self.r = redis.StrictRedis(host=server.REDIS_DEFAULT_HOST, port=server.REDIS_DEFAULT_PORT,
                                   decode_responses=True)
        self.timeout = server.REDIS_DEFAULT_EXPIRE 

def get_redis_connection(self, group, shard=0, fallback_to_default=True):
        """
        Returns a Redis connection for the given group and shard

        Args:
            group (str): The name of the group for which to return the Redis connection
            shard (int): The number of the shard for which to return the Redis connection
            fallback_to_default (bool): If we can't find a connection for given group, whether to fallback to the \
            'default` group name

        Returns:
            redis.StrictRedis: The Redis connection
        """
        def _inner_get_redis_connection():
            try:
                connection = self._get_redis_connection(group, shard)
                self.__redis_connections[group][shard] = connection
            except:
                if (group != const.DEFAULT_REDIS_GROUP_NAME) and fallback_to_default:
                    self.__redis_connections[group][shard] = self.redis_pool
                else:
                    raise

        if group not in self.__redis_connections:
            self.__redis_connections[group] = dict()
            _inner_get_redis_connection()
        elif shard not in self.__redis_connections[group]:
            _inner_get_redis_connection()

        return self.__redis_connections[group][shard]