Python StrictRedis.incr方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
class DbRedis(Db):
    def __init__(self):
        super().__init__()
        self.redis = StrictRedis(**dbSettings)

    def generateKey(self):
        return self.redis.incr("id")

    def store(self, key, objSerial):
        self.redis.setex(key, TTL, objSerial)

    def retrieve(self, key):
        return self.redis.get(key)

    def lenList(self, name):
        return self.redis.llen(name)

    def listAppend(self, name, val):
        self.redis.lpush(name, val)

    def listPopLeft(self, name):
        return self.redis.lpop(name)

    def retrieveList(self, name):
        return self.redis.lrange(name, 0, -1)

    def removeFromList(self, name, item):
        self.redis.lrem(name, item, 0)

    def keyExists(self, key):
        return self.redis.exists(key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
 def set(cls, name, value):
     db = StrictRedis()
     with db.pipeline() as pipe:
         try:
             cls._set(pipe, name, value)
             pipe.execute()            
             db.incr(name+'::v')
             return
         except ResponseError: 
             pass
     
     # RPUSH bug in some platform                            
     db = StrictRedis()
     with db.pipeline() as pipe:
         cls._set(pipe, name, value, True)
         pipe.execute()            
         db.incr(name+'::v')

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
class RedisBackend(Backend):

    def __init__(self, config):
        super(RedisBackend, self).__init__(config)
        self.redis = StrictRedis(host=config.get("host", "localhost"),
                                 port=config.get("port", 6379),
                                 db=config.get("db", 0))
        self.namespace = config.get("namespace", "short:")

    def furl(self, name):
        return self.namespace + "url:" + name

    def fvisits(self, name):
        return self.namespace + "visits:" + name

    def next_name(self):
        name = None
        while 1:
            name = hashids.encrypt(
                self.redis.incr(self.namespace + "meta:num"))
            if not self.exists(name):
                break
        return name

    def exists(self, name):
        return self.redis.exists(self.furl(name))

    def set(self, link):
        if self.redis.exists(self.furl(link.name)):
            raise NameUnavailableError(link.name)
        self.redis.set(self.furl(link.name), link.url)
        self.redis.set(self.fvisits(link.name), 0)

    def get(self, name):
        rawlink = self.redis.get(self.furl(name))
        if not rawlink:
            raise NotFoundError(name)
        link = Link(name=name,
                    url=rawlink.decode("utf-8"),
                    visits=int(
                        self.redis.get(self.fvisits(name)) or 0
                    ))
        return link

    def visit(self, name):
        self.redis.incr(self.fvisits(name))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
class RedisDB(object):

    def __init__(self):
        if not hasattr(RedisDB, 'pool'):
            RedisDB.createPool()
        self.r = StrictRedis(connection_pool = RedisDB.pool)

    @staticmethod  
    def createPool():  
        RedisDB.pool = redis.ConnectionPool(  
        host = '127.0.0.1',  
        port = 6379,  
        db   = 0
        )

    def saveToRedis(self, receiver, to_station_ab, to_station_name, from_station_ab, from_station_name, querydate, purpose_code, noticetime, publishtime):
        '''将需要抓取的信息存入redis'''
        uid = self.r.incr('uid')    
        tickets_info = {'uid':uid, 'receiver':receiver, 'to_station_ab':to_station_ab, 'to_station_name':to_station_name, 'from_station_ab':from_station_ab,'from_station_name':from_station_name, 'querydate':querydate, 'purpose_code':purpose_code, 'noticetime':noticetime, 'publishtime': publishtime}
        self.r.zadd('email_que_set_all', uid, str(tickets_info))
        if noticetime == '9am':
            self.r.zadd('email_que_set_9am', uid, str(tickets_info))
        elif noticetime == '11am':
            self.r.zadd('email_que_set_11am', uid, str(tickets_info))
        elif noticetime == '3pm':
            self.r.zadd('email_que_set_3pm', uid, str(tickets_info))
        elif noticetime == '5pm':
            self.r.zadd('email_que_set_5pm', uid, str(tickets_info))
        self.r.save()

    def getStation(self, set, name):
        return self.r.hget(set, name)

    def zrevrange(self, set, begin, end):
        return self.r.zrevrange(set, begin, end)
    
    def zremrangebyscore(self, queue, uid):
        return self.r.zremrangebyscore(queue, uid, uid)

    def station_validate(self, form, field):  
        ''' 
        表单tostation和tostation验证函数
        '''
        if not self.r.getStation(field.data):
     
            raise ValidationError(u'木有这个站') 

    def saveJSONToSet(self, setName, json):
        if not self.r.exists(setName):
            for i, name in enumerate(json):
                self.r.hset(setName, name, json[name])
                print 'insert'+name
            self.r.save()
        else:
            pass

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
def register_build_result(opts=None, failed=False):
    """
    Remember fails to redis.
    Successful build resets counter to zero.

    :param opts: BackendConfig, when opts not provided default config location will be used
    :param boolean failed: failure flag
    :param str origin: name of component produced failure, default: `builder`
    """
    if opts is None:
        opts = BackendConfigReader().read()

    # TODO: add config options to specify redis host, port
    conn = StrictRedis()  # connecting to default local redis instance

    key = CONSECUTIVE_FAILURE_REDIS_KEY
    if not failed:
        conn.set(key, 0)
    else:
        conn.incr(key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
class SearchIndex(object):

    def __init__(self, *args, **kwargs):
        self.redis = StrictRedis(*args, **kwargs)

    def index(self, value, uid=None, key='text', autocompletion=False, **kwargs):
        if not uid:
            uid = self.redis.incr('indexed')
        self.redis.hset(uid, key, value)
        pipe = self.redis.pipeline()
        if autocompletion:
            for i, word in enumerate(_get_words(value, weighted=False)):
                for i, letter in enumerate(word):
                    if len(word) > i + 1:
                        pipe.zadd('a:' + word[:2+i], 0, uid+':'+word)
        else:
            for word, value in _get_words(value).iteritems():
                pipe.zadd('w:' + word, value, uid)
        pipe.execute()

    def index_autocomplete(self, value, uid=None, key='text'):
        self.index(value, uid, key, autocompletion=True)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
class Uptime(object):
    jobs = Queue()  # TODO: Are the consequences of this intended?

    def __init__(self, config):
        self.running = False
        self.config = config
        self.checks = []
        self.pool = gevent.pool.Group()
        self.config_path = 'uptime_config:'
        self.results_path = 'uptime_results:' + self.config.source + ':'
        self.stats_path = 'uptime_stats:'

        if self.config.slack_url and self.config.slack_channel:
            self.notifier = SlackNotifier(self.config.slack_url,
                                          self.config.slack_channel)
        else:
            log.warn('No notifiers configured')
            self.notifier = None

        self.redis = StrictRedis(host=self.config.redis_host, port=self.config.redis_port)

        if not self.redis.exists(self.stats_path):
            self.redis.set(self.stats_path + 'total_checks', 0)

        self.start()

    def start(self):
        self.running = True
        workers = [gevent.spawn(self._check_worker) for _ in range(1, self.config.concurrency)]
        workers.append(gevent.spawn(self._controller))

        t = Thread(target=self._watcher)
        t.daemon = True
        t.start()

        gevent.signal(signal.SIGQUIT, gevent.killall, workers)
        gevent.signal(signal.SIGINT, gevent.killall, workers)

        gevent.joinall(workers)

    def _watcher(self):
        """
        Worker to poll redis for key changes, updating accordingly
        """
        while self.running:
            configs = self._get_configs()

            # add all checks
            for c in configs:
                self._add_check(c)

            # cleanup removed checks
            config_ids = [str(c['check_id']) for c in configs]
            for c in self.checks:
                if c.check_id not in config_ids:
                    self._remove_check(c.check_id)

            sleep(5)

    def _get_configs(self):
        pattern = self.config_path + '*'
        return [json.loads(self.redis.get(k).decode(self.config.encoding)) for
                k in self.redis.keys(pattern)]

    def _controller(self):
        """
        Controller worker. Submits any overdue checks to queue.
        """
        while self.running:
            now = datetime.utcnow()

            [self.jobs.put_nowait(c) for c in self.checks if
             (now - c.last).seconds > c.interval]

            gevent.sleep(0)

    def _check_worker(self):
        """
        Worker to perform url checks
        """
        logging.info('[{}] worker started'.format(id(self)))
        while self.running:
            while not self.jobs.empty():
                check = self.jobs.get()

                log.info('checking %s' % check.url)

                result = self._check_url(check.url, check.content)
                self.redis.incr(self.stats_path + 'total_checks')

                check.response_time = result['elapsed']

                if result['ok']:
                    check.last = datetime.utcnow()
                    check.ok()
                else:
                    check.failures += 1

                if check.failures > 3 and not check.notified and self.notifier:
                    log.info('sending notification for failed check')
#.........这里部分代码省略.........

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
        gender = int(gender) % 2
    except StandardError, error_info:
        logbook.error('error:{}, card:{}'.format(error_info, card))
        return
    # prepare doc
    key_list = []
    key_list.extend(position_code)
    key_list.append('year:{}'.format(year))
    key_list.append('month:{}'.format(month))
    key_list.append('female') \
        if gender is 0 \
        else key_list.append('male')
    msetnx_dict = {item: 0 for item in key_list}
    # count
    r_db.msetnx(msetnx_dict)
    incr = lambda key: r_db.incr(key)
    map(incr, key_list)


def save_position(level):
    # dump the all province data into mongo

    # get all position key
    if level is 'province':
        positions = r_db.keys('??0000')
    elif level is 'city':
        positions = r_db.keys('????00')

    # produce every position
    for position in positions:
        # get the count of position

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
    gender = choice(["F", "M"])
    random_city = choice(test_cities)

    email = None
    login = None

    while email in emails_used:
        email = fake.free_email()

    while login in logins_used:
        last_fake_login += 1
        login = 'fake_' + str(last_fake_login)

    data = {
        'birthday': datetime(choice(range(1960, 1995)), choice(range(1, 13)), choice(range(1, 28))),
        'first_name': fake.first_name_male() if gender is "M" else fake.first_name_female(),
        'last_name': fake.last_name_male() if gender is "M" else fake.last_name_female(),
        'gender': gender,
        'password': fake.password(length=10),
        'email': email,
        'description': fake.text(max_nb_chars=150),
        'sid': r.get('sid'),
        'fake': True,
        'coordinates': random_city['coordinates'],
        'login': login,
        'city': random_city['city'],
        'country': random_city['country']
        }
    database.save(data)
    r.incr('sid')

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
class Graph(object):
    """
        Main interface for adding/removing/looking up
        graph elements.
        
        basic usage:
        you'll add and remove elements via:
        -add_node()/add_edge()
        -del_node()/del_edge()
        
        you can also look up nodes by property:
        get_nodes()/get_edges()

        you can query by property with regex:
        find_nodes()/find_edges()

        all of these methods will return a list of 
        Node() or Edge() objects. From these, you are
        able to look at incoming or ourgoing edges, 
        parent and child nodes, and individually access
        and modify their properties.
        
        Usage::
            >>> from rgr import Graph
            >>> g = Graph()
            >>> g2 = Graph('mygraph')

        :param name: default -> 'rgr'; the namespace for your graph within redis.
    """
    #TODO: better errors
    def __init__(self, name='rgr'):
        self.redis = Redis()
        self.name = name
        self.next_nid_key = self.name + ':next_nid' #scalar
        self.next_eid_key = self.name + ':next_eid' #scalar
        self.nodes_key = self.name + ':nodes'       #set
        self.edges_key = self.name + ':edges'       #set
        if not self.redis.exists(self.next_nid_key):
            self.redis.set(self.next_nid_key, 0)
        if not self.redis.exists(self.next_eid_key):
            self.redis.set(self.next_eid_key, 0)

    def add_node(self, **kwargs):
        """
            Add a node to the graph.

            Usage::
                >>> from rgr import Graph
                >>> g = rgr.Graph()
                >>> n = g.add_node() #blank node
                >>> n2 = g.add_node(name='john', type='person')
        
            :param kwargs: node properties to initialize
            :return: rgr.Node representing the node you just created.
        """
        new_nid = self.redis.get(self.next_nid_key)
        new_node = Node(self, new_nid)
        self.redis.sadd(self.nodes_key, new_nid)
        for k in kwargs:
            new_node.prop.__setattr__(k, kwargs[k])
            self._index(new_node.name, k, kwargs[k]) 
        self.redis.incr(self.next_nid_key)
        return new_node

    def add_edge(self, parent, child, **kwargs):
        """
            Add an edge between two nodes.
            
            Usage::
                
                >>> from rgr import Graph
                >>> g = Graph()
                >>> john = g.add_node(name='john')
                >>> mary = g.add_node(name='mary')
                >>> e = g.add_edge(john, mary, rel='friends', weight=20)
            :param parent:  edge start node (rgr.Node or node ID)
            :param child:   edge end node (rgr.Node or node ID)
            :param kwargs:  edge properties to initialize
            :return:        rgr.Edge representing the edge you just created.
        """
        new_eid = self.redis.get(self.next_eid_key)
        new_edge = Edge(self, new_eid) 
        self.redis.sadd(self.edges_key, new_eid) 
        for k in kwargs:
            new_edge.prop.__setattr__(k, kwargs[k])
            self._index(new_edge.name, k, kwargs[k]) 
        if type(parent) is Node:
            parent = parent.id
        else:
            parent = str(parent)
        if type(child) is Node:
            child = child.id
        else:
            child = str(child)
        if not self.redis.sismember(self.nodes_key, parent):
            raise ValueError(parent)
        if not self.redis.sismember(self.nodes_key, child):
            raise ValueError(child)
        self.redis.set('{}:e:{}:in'.format(self.name, new_eid), parent)
        self.redis.set('{}:e:{}:on'.format(self.name, new_eid), child)
#.........这里部分代码省略.........

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
def stream_frames(stream, pafy_video = None):
    r = StrictRedis('localhost')
    try:
        r.incr('counter') # keep track of how many processes are running
        demo_diff = 0
        video_length = pafy_video.length if pafy_video else (5412-demo_diff if 'rubakov1' in stream else 5000)
        if pafy_video:
            yield server_event_msg({'video_length': pafy_video.length,
                                    'video_title': pafy_video.title,
                                    'video_desc': pafy_video.description,
                                    'video_author': pafy_video.author,
                                    'video_url': pafy_video.url},
                                   'onstart')
        else:
            if 'rubakov1' in stream:
                demo_diff = 4*60 # the demo video is four min in
                yield server_event_msg({"video_author": "Galileo Galilei",
                                        "video_length": 5412-demo_diff,
                                        "video_title": "Early Universe - V. Rubakov - lecture 1/9",
                                        "video_url": "https://www.youtube.com/watch?v=XsqtPhra2f0",
                                        "video_desc": "GGI lectures on the theory of fundamental interactions, January 2015\nhttp://heidi.pd.infn.it/html/GGI/index.php"},
                                       'onstart')
            else:
                yield server_event_msg({'video_length': 5000,'video_title': stream }, 'onstart')
                
     
        hist = defaultdict(float)
        it = utils.find_text_in_video(
                 utils.get_frames_from_stream(stream,3),
                 lambda frame,base_frames: utils.find_text_in_frame(frame, base_frames, proba_threshold=0.5))
     
        for dtype, data in it:
            if dtype == 'new_frame':
                yield server_event_msg({'sec': int(data[0])},'onprogress')
            elif dtype == 'new_blob':
                yield server_event_msg({'img': utils.img_to_base64_bytes(data['blob']), #utils.img_to_base64_bytes(255-np.nan_to_num(abs(blob))),
                                                 'sec': int(data['sec']+demo_diff),
                                                 'proba': round(data['proba'],2),
                                                 'left_corner': data['left_corner'],
                                                 'size': data['blob'].shape,
                                                 'n_sameblobs': data['n_sameblobs'],
                                                 # 'frame': utils.img_to_base64_bytes(data['frame'])
                                             })
                if 'blob_bw' not in data: data['blob_bw'] = img_proc_utils.otsu_thresholded(data['blob'])
                hist[(int(data['sec']+demo_diff)/60)] += np.count_nonzero(data['blob_bw'][data['blob_bw']>0])
                
                # print hist, {'hist': [{'x': k, 'y': v} for k,v in hist.iteritems()]}
                # yield server_event_msg({'hist': [{'x': k, 'y': int(v/10.)} for k,v in hist.iteritems()]}, 'onhist')
                yield server_event_msg({'hist': [{'x': i, 'y':  hist.get(i,0)} for i in xrange(video_length/60)]}, 'onhist')
            elif dtype == "erased_blob":
                yield server_event_msg({'sec': int(data['sec']+demo_diff),
                                        'removed_sec': int(data['removed_at_sec']+demo_diff),
                                        'left_corner': data['left_corner']},
                                       'onerasure')
                hist[(int(data['removed_at_sec']+demo_diff)/60)] -= np.count_nonzero(data['blob_bw'][data['blob_bw']>0])
                yield server_event_msg({'hist': [{'x': i, 'y':  hist.get(i,0)} for i in xrange(video_length/60)]}, 'onhist')
     
        yield server_event_msg({'end':True}, 'onend')
        raise StopIteration
    finally:
        r.decr('counter')        

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import incr [as 别名]
redis = StrictRedis(host='127.0.0.1',port=6379)
redis_test = RedisKey(redis)

print 'start'
REDIS_STAR_COL_COUNT = redis_test.StarCollectCount()
print 'end'
print REDIS_STAR_COL_COUNT

test1 = redis_test.Good()
print test1

test2 = redis_test.Good()
print test2

test_attr = redis_test.test_attr('%s')
print test_attr % 'hh'

redis.hset(REDIS_STAR_COL_COUNT,'good','ok')

result = redis.hget(REDIS_STAR_COL_COUNT,'hello')

print result
rts = redis.hgetall(REDIS_STAR_COL_COUNT)
print rts
id = redis.incr('REDIS_KEY_ID')
kk = redis_keyer.encode(id)
print kk
print id

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

#.........这里部分代码省略.........

             RPUSH shop.orders.fullfillment 1


    Reading message from queue
    --------------------------------------------------------------------------

    sub.consume()
        -->  BLPOP shop.orders.fullfillment
             -> 1

             GET shop.orders.messages.1
             -> "order data"

        <--  "order data"

    Destroying the message queue
    --------------------------------------------------------------------------

    sub.unsubscribe()
        -->  SREM shop.orders.consumers fullfillment

             DEL shop.orders.fullfillment.messages
    """

    def __init__(self, namespace, redis_url=("localhost", 6379)):
        """
        Create instance of PyRPS.
        @param redis_url Redis instance address (tuple containing (hostname, port)).
        @param namespace Namespace to separate Pub/Sub instance from another running on the same redis host.
        """

        self.namespace = namespace

        if isinstance(redis_url, tuple):
            self.redis = StrictRedis(host=redis_url[0], port=redis_url[1])
        elif isinstance(redis_url, str):
            self.redis = StrictRedis(host=redis_url)


    def subscribe(self, queue, consumer_id):
        """
        Subscribe to message queue. Yields messages as they appear in
        the queue.
        @param queue Queue name
        @param consumer_id Consumer name
        """

        # Add myself to the list of consumers, if not already present.
        self.redis.sadd(self._ns_subscriptions(queue), consumer_id)

        return Subscription(self, queue, consumer_id)


    def publish(self, queue, message, ttl=3600):
        """
        Publish new message into queue.
        @param queue Queue name.
        @param message Message data.
        @param ttl How long the message should stay alive.
        """

        # Get next message ID
        message_id = self.redis.incr(self._ns_nextid())

        # Push message to queue
        self.redis.setex(self._ns_message(queue, message_id), ttl, message)
        
        # List all consumers of given queue
        consumers = self.redis.smembers(self._ns_subscriptions(queue))

        # Publish the message to all the consumers.
        for consumer in consumers:
            self.redis.rpush(self._ns_queue(queue, consumer), message_id)


    def _ns(self, *args):
        """ Convinience method to retrieve names of redis keys including
        configured namespace. """
        return "%s.%s" % (self.namespace, ".".join([str(arg) for arg in args]))


    def _ns_subscriptions(self, queue):
        """ Return key for subscribers list for given queue. """
        return self._ns(queue, "consumers")


    def _ns_nextid(self):
        """ Return key for nextid counter. """
        return self._ns("nextid")


    def _ns_message(self, queue, message_id):
        """ Return key for retrieving message. """
        return self._ns(queue, "messages", message_id)


    def _ns_queue(self, queue, consumer_id):
        """ Return key for queue for one consumer. """
        return self._ns(queue, consumer_id, "messages")