本文整理汇总了Python中redis.StrictRedis.incr方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.incr方法的具体用法?Python StrictRedis.incr怎么用?Python StrictRedis.incr使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.incr方法的13个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: DbRedis
# 需要导入模块: 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)
示例2: set
# 需要导入模块: 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')
示例3: RedisBackend
# 需要导入模块: 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))
示例4: RedisDB
# 需要导入模块: 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
示例5: register_build_result
# 需要导入模块: 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)
示例6: SearchIndex
# 需要导入模块: 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)
示例7: Uptime
# 需要导入模块: 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')
#.........这里部分代码省略.........
示例8: int
# 需要导入模块: 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
示例9: choice
# 需要导入模块: 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')
示例10: Graph
# 需要导入模块: 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)
#.........这里部分代码省略.........
示例11: stream_frames
# 需要导入模块: 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')
示例12: StrictRedis
# 需要导入模块: 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
示例13: PyRPS
# 需要导入模块: 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")