Python StrictRedis.set方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class Redis:
    """
    To store and query local/remote Redis server.
    """

    def __init__(self, host='localhost',
                       port=6379,
                       db=0,
                       password=None):
        self.r = StrictRedis(host, port, db, password)

    def __del__(self):
        del(self.r)

    def update(self, track):
        self.r.set(track.key, track.stats())

    def lookup(self, keyword):
        # TODO: add option for caseless search
        return self.r.keys('*' + keyword + '*')

    def retrieve(self, key):
        if isinstance(key, list):
            return self.get_all(key)
        return Track.from_redis(key, self.r.get(key))

    def get_all(self, keys):
        tracks = []
        for key in keys:
            tracks.append(Track.from_redis(key, self.r.get(key)))
        return tracks

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class RedisManager(NoSqlManager):
    def __init__(self,
                 namespace,
                 url=None,
                 data_dir=None,
                 lock_dir=None,
                 **params):
        self.db = params.pop('db', None)
        self.dbpass = params.pop('password', None)
        self.connection_pool = params.get('redis_connection_pool', None)
        self.expires = params.get('expires', params.get('expiretime', None))
        NoSqlManager.__init__(self,
                              namespace,
                              url=url,
                              data_dir=data_dir,
                              lock_dir=lock_dir,
                              **params)

    def open_connection(self, host, port, **params):
        if not self.connection_pool:
            self.connection_pool = ConnectionPool(host=host, port=port, db=self.db,
                    password=self.dbpass)
        self.db_conn = StrictRedis(connection_pool=self.connection_pool, **params)
    
    def __contains__(self, key):
        return self.db_conn.exists(self._format_key(key))

    def set_value(self, key, value, expiretime=None):
        key = self._format_key(key)
        # beaker.container.Value.set_value calls NamespaceManager.set_value
        # however it (until version 1.6.4) never sets expiretime param.
        #
        # Checking "type(value) is tuple" is a compromise
        # because Manager class can be instantiated outside container.py (See: session.py)
        if (expiretime is None) and (type(value) is tuple):
            expiretime = value[1]
        # If the machinery above fails, then pickup the expires time from the
        # init params.
        if not expiretime and self.expires is not None:
            expiretime = self.expires
        # Set or setex, according to whether we got an expires time or not.
        if expiretime:
            self.db_conn.setex(key, expiretime, pickle.dumps(value, 2))
        else:
            self.db_conn.set(key, pickle.dumps(value, 2))

    def __delitem__(self, key):
        self.db_conn.delete(self._format_key(key))

    def _format_key(self, key):
        return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))

    def _format_pool_key(self, host, port, db):
        return '{0}:{1}:{2}'.format(host, port, self.db)

    def do_remove(self):
        self.db_conn.flush()

    def keys(self):
        return self.db_conn.keys('beaker:%s:*' % self.namespace)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def feed_db(container_id, stats):
    """ Store data to Redis.
        args:
         - constainer_id : (str) container's hash 12 first characters
         - stats : a dictionary of stats
    """
    if DEBUG:
        print('feed db with container {} stats'.format(container_id))

    # convert the time provided by stats to UTC format, parse it with strptime,
    # and transform it again to the desired REDIS_KEY_TIMESTAMP format
    instant_str = stats['read'][:-9]+stats['read'][-6:].replace(':', '')
    instant = datetime.strptime(instant_str, '%Y-%m-%dT%H:%M:%S.%f%z')
    timestamp = instant.strftime(REDIS_KEY_TIMESTAMP)

    r = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB)
    for resource, value in stats.items():
        if resource != 'read':
            key = REDIS_KEY.format(timestamp=timestamp,
                                   container_id=container_id,
                                   resource=resource)

            r.set(key, dumps(value))
            r.expire(key, REDIS_EXPIRE_TIME)

            if DEBUG:
                print("Stored {} => {}".format(key, value))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class RedisManager(NoSqlManager):
    def __init__(self,
                 namespace,
                 url=None,
                 data_dir=None,
                 lock_dir=None,
                 **params):
        self.db = params.pop('db', None)
        self.connection_pools = {}
        NoSqlManager.__init__(self,
                              namespace,
                              url=url,
                              data_dir=data_dir,
                              lock_dir=lock_dir,
                              **params)

    def open_connection(self, host, port, **params):
        pool_key = self._format_pool_key(host, port, self.db)
        if pool_key not in self.connection_pools:
            self.connection_pools[pool_key] = ConnectionPool(host=host,
                                                             port=port,
                                                             db=self.db)
        self.db_conn = StrictRedis(connection_pool=self.connection_pools[pool_key],
                                   **params)

    def __contains__(self, key):
        return self.db_conn.exists(self._format_key(key))

    def set_value(self, key, value, expiretime=None):
        key = self._format_key(key)

        #
        # beaker.container.Value.set_value calls NamespaceManager.set_value
        # however it (until version 1.6.4) never sets expiretime param.
        #
        # Checking "type(value) is tuple" is a compromise
        # because Manager class can be instantiated outside container.py (See: session.py)
        #
        if (expiretime is None) and (type(value) is tuple):
            expiretime = value[1]

        if expiretime:
            self.db_conn.setex(key, expiretime, pickle.dumps(value, 2))
        else:
            self.db_conn.set(key, pickle.dumps(value, 2))

    def __delitem__(self, key):
        self.db_conn.delete(self._format_key(key))

    def _format_key(self, key):
        return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))

    def _format_pool_key(self, host, port, db):
        return '{0}:{1}:{2}'.format(host, port, self.db)

    def do_remove(self):
        self.db_conn.flush()

    def keys(self):
        return self.db_conn.keys('beaker:%s:*' % self.namespace)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class RedisDataStore(DataStore):
    """Redis-backed datastore object."""

    def __init__(self, number=0):
        redis_host = os.environ.get('REDIS_PORT_6379_TCP_ADDR')
        redis_port = os.environ.get('REDIS_PORT_6379_TCP_PORT')
        self.redis_conn = StrictRedis(host=redis_host, port=redis_port,
                                      db=number)

    def __setitem__(self, k, v):
        self.redis_conn.set(k, v)

    def __getitem__(self, k):
        return self.redis_conn.get(k)

    def __delitem__(self, k):
        self.redis_conn.delete(k)

    def get(self, k):
        return self.redis_conn.get(k)

    def __contains__(self, k):
        return self.redis_conn.exists(k)

    def todict(self):
        #TODO(tvoran): use paginate
        #TODO(tvoran): do something besides multiple gets
        data = {}
        for key in self.redis_conn.keys():
            data[key] = self.get(key)
        return data

    def clear_all(self):
        self.redis_conn.flushdb()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class CacheHelper(object):
    """A thin wrapper on top of Redis."""
    def __init__(self, host="localhost", port=6379, db=0):
        self.host = host
        self.port = port
        self.db = db

    def __enter__(self):
        self.r = StrictRedis(host=self.host, port=self.port, db=self.db)
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        try:
            if any((exc_type, exc_value, traceback,)):
                raise
        finally:
            pass

    def get(self, key):
        return self.r.get(key) if key in self.r.keys() else None

    def set(self, key, json):
        self.r.set(key, json)

    def keys(self):
        return self.r.keys()

    def reset(self):
        for key in self.keys():
            self.r.delete(key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
 def test_get_text(self):
     r = StrictRedis()
     r.set('test_get_2', "Open Mining")
     DW = DataWarehouse()
     self.assertEquals(
         DW.get("test_get_2", content_type='application/text'),
         "Open Mining")

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
 def sync_get(self, identity, *args, **kwargs):
     """
     For getting data from cache
     :param identity: Unique Integer for the data
     :param args: Args for the sync function. (Default: None)
     """
     redis = StrictRedis(connection_pool=self.redis_pool)
     key = key_generator(self.key, identity)
     try:
         if redis.exists(key):
             data = self.get_func(redis.get(key))
         else:
             data = self.sync_func(identity, *args, **kwargs)
             if self.expire:
                 self._setex(redis, key, self.set_func(data))
             else:
                 redis.set(key, self.set_func(data))
         if data is not None or data != "":
             return data
         return None
     except RedisError as re:
         self.log.error("[REDIS] %s", str(re))
         data = self.sync_func(identity, args)
         return data
     finally:
         del redis

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
    def post(self, request):
        course_code = request.POST.get('course_code')
        duration = int(request.POST.get('duration'))

        r = StrictRedis(host='localhost', port=6379, db=0)
        r.set('{}{}'.format(self.redis_key, course_code), course_code)
        r.expire('{}{}'.format(self.redis_key, course_code), duration*3600)

        return Response({'success': 'active_class stored'})









#def get_client_ip(request):
#    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
#    if x_forwarded_for:
#        ip = x_forwarded_for.split(',')[-1].strip()
#    else:
#        ip = request.META.get('REMOTE_ADDR')
#    return ip

#or django-ipaware

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
 def test_list_preparation_with_invalid_type(self) -> None:
     """
     When a list key is already there with a wrong type
     """
     redis = StrictRedis(connection_pool=self.__pool)
     redis.set(self.__config['queue'], 'test')
     self.assertRaises(ValueError, RedisQueueAccess, self.__config)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class RedisManager(NoSqlManager):
    def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
        self.connection_pool = params.pop('connection_pool', None)
        NoSqlManager.__init__(self, namespace, url=url, data_dir=data_dir, lock_dir=lock_dir, **params)

    def open_connection(self, host, port, **params):
        self.db_conn = StrictRedis(host=host, port=int(port), connection_pool=self.connection_pool, **params)

    def __contains__(self, key):
        log.debug('%s contained in redis cache (as %s) : %s'%(key, self._format_key(key), self.db_conn.exists(self._format_key(key))))
        return self.db_conn.exists(self._format_key(key))

    def set_value(self, key, value, expiretime=None):
        key = self._format_key(key)

        #XXX: beaker.container.Value.set_value calls NamespaceManager.set_value
        # however it(until version 1.6.3) never sets expiretime param. Why?

        if expiretime:
            self.db_conn.setex(key, expiretime, pickle.dumps(value))
        else:
            self.db_conn.set(key, pickle.dumps(value))

    def __delitem__(self, key):
        self.db_conn.delete(self._format_key(key))

    def _format_key(self, key):
        return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))

    def do_remove(self):
        self.db_conn.flush()

    def keys(self):
        return self.db_conn.keys('beaker:%s:*' % self.namespace)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def search():
    query = request.args["q"]
    ands = request.args["and"] if "and" in request.args else ""
    ors = request.args["or"] if "or" in request.args else ""
    nots = request.args["not"] if "not" in request.args else ""

    try:
        page = int(request.args["page"])
    except:
        page = 1

    # cache server
    redis = StrictRedis(host="localhost")

    # start measuring elapsed time
    start = time.time()

    # try to load result from cache
    key = json.dumps({
        "q": query,
        "a": ands,
        "o": ors,
        "n": nots
    })
    cache_result = redis.get(key)

    items = cPickle.loads(cache_result) if cache_result else None
    if not items:
        items = SearchEngine(get_db(), query, ands, nots, ors) \
            .search()

        # store results in cache
        redis.set(key, cPickle.dumps(items))

    elapsed_time = (time.time() - start) * 1000

    items_count = len(items)
    pages_count = items_count // 10
    if pages_count < items_count / 10.0:
        pages_count += 1

    if page > pages_count:
        page = pages_count

    # convert to index based
    page -= 1

    # calculate last item within this page
    last_item_index = (page * 10) + 10

    json_data = json.dumps({
        "items": items[page * 10: last_item_index if last_item_index < items_count else items_count],
        "total_count": items_count,
        "elapsed_time": int(elapsed_time)
    }, cls=SuperListJsonEncoder)

    return Response(response=json_data,
                    status=200,
                    mimetype="application/json")

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class RedisRequestLogger(RequestLoggerBase):
    """A faster alternative to the default logger, but requiring more configuration"""
    
    def __init__(self):
        from redis import StrictRedis
        
        super(RedisRequestLogger, self).__init__()
        self.db = StrictRedis(
            host = getattr(settings, 'API_REDIS_HOST', 'localhost'),
            port = getattr(settings, 'API_REDIS_PORT', 6379),
            db = getattr(settings, 'API_REDIS_DB', 0),
            password = getattr(settings, 'API_REDIS_PASSWORD', '')
        )
    
    def get_key(self, app):
        return 'bambu-api-requests-%s' % app.key
    
    def log_request(self, app):
        """Saves the number of requests within the given timeframe to the Redis database"""
        
        timestamp = self.get_timestamp()
        key = self.get_key(app)
        values = self.db.get(key)
        
        if values:
            try:
                values = pickle.loads(values)
            except:
                values = {}
        else:
            values = {}
        
        if values.has_key(timestamp):
            values = {
                timestamp: values[timestamp] + 1
            }
        else:
            values = {
                timestamp: 1
            }
        
        self.db.set(key, pickle.dumps(values))
    
    def get_request_count(self, app, timestamp):
        """Returns the number of requests by the specified app, within the specified timeframe"""
        
        values = self.db.get(
            self.get_key(app)
        )
        
        if values:
            try:
                values = pickle.loads(values)
            except:
                values = {}
        else:
            values = {}
        
        return values.get(timestamp) or 0

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def control_me():
    r = StrictRedis()
    print("Human controller started. Press 'q' to exit ... ")
    while True:
        c = getch()
        if c == 'q':
            return
        r.set("action", c)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
    def post(self, request):
        course_code = request.POST.get('course_code')
        duration = int(request.POST.get('duration'))

        r = StrictRedis(host='localhost', port=6379, db=0)
        r.set('{}{}'.format(self.redis_key, course_code), course_code)
        r.expire('{}{}'.format(self.redis_key, course_code), duration*3600)

        return Response({'success': 'active_class stored'})