Python redis.delete函数代码示例

def deltestdata_api():
    print 'deleting test data'
    for email2key in [redis_book_key_from_email,
                      redis_auth_key_from_email]:
        print email2key('[email protected]')
        redis.delete(email2key('[email protected]'))
    return jsonify({'ip': get_remote_ip()}), 200

def resubmit_jobs():
    if config.get('ckan.harvest.mq.type') != 'redis':
        return
    redis = get_connection()

    log.debug('_create_or_update_package')
    harvest_object_pending = redis.keys('harvest_object_id:*')
    for key in harvest_object_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        if (datetime.datetime.now() - date_of_key).seconds > 180: # 3 minuites for fetch and import max
            redis.rpush('harvest_object_id',
                json.dumps({'harvest_object_id': key.split(':')[-1]})
            )
            redis.delete(key)

    harvest_jobs_pending = redis.keys('harvest_job_id:*')
    for key in harvest_jobs_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        if (datetime.datetime.now() - date_of_key).seconds > 7200: # 3 hours for a gather
            redis.rpush('harvest_job_id',
                json.dumps({'harvest_job_id': key.split(':')[-1]})
            )
            redis.delete(key)

def generateSet(products,tmpSetName):
    '''
    Generate a temporary union set for the given products list.
    '''
    print "generateSet()"
    
    if len(products)==0:
        print "Parameter(products) is empty!"
        return None
    
    redis = brconfig.getRedis()
    pipe = redis.pipeline(transaction=True)    
    
    sets=[]
    for p in products:
        sets.append("ids:i:android.os.Build.PRODUCT:%s"%p)
        
    pipe.sunionstore(tmpSetName,sets)
    ret=pipe.execute()
    
    if ret[0]==0:
        redis.delete(tmpSetName)
        print "Generated an empty set!"
        return None
    else:  
        return tmpSetName

def resubmit_jobs():
    '''
    Examines the fetch and gather queues for items that are suspiciously old.
    These are removed from the queues and placed back on them afresh, to ensure
    the fetch & gather consumers are triggered to process it.
    '''
    if config.get('ckan.harvest.mq.type') != 'redis':
        return
    redis = get_connection()

    # fetch queue
    harvest_object_pending = redis.keys(get_fetch_routing_key() + ':*')
    for key in harvest_object_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        # 3 minutes for fetch and import max
        if (datetime.datetime.now() - date_of_key).seconds > 180:
            redis.rpush(get_fetch_routing_key(),
                json.dumps({'harvest_object_id': key.split(':')[-1]})
            )
            redis.delete(key)

    # gather queue
    harvest_jobs_pending = redis.keys(get_gather_routing_key() + ':*')
    for key in harvest_jobs_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        # 3 hours for a gather
        if (datetime.datetime.now() - date_of_key).seconds > 7200:
            redis.rpush(get_gather_routing_key(),
                json.dumps({'harvest_job_id': key.split(':')[-1]})
            )
            redis.delete(key)

def diagnose_cb():
  user_session = get_session(redis,request.values.get('CallSid'))
  symptom = urllib.unquote(request.args.get('symptom'))
  print symptom
  resp = twilio.twiml.Response()
  digit_pressed = request.values.get('Digits', None)
  if digit_pressed == "1":
    user_session['symptom_whitelist'].append(symptom)
    set_session(redis,request.values.get('CallSid'), user_session)
  else:
    user_session['symptom_blacklist'].append(symptom)
    set_session(redis,request.values.get('CallSid'), user_session)
  diseases = symptomelimination.calculate_probability_for_disease(user_session['location'], user_session['symptom_whitelist'])
  # its for the case that no user input is made (so people will not have a disease without symptom)
  if len(user_session['symptom_whitelist']) == 0:
    for disease in diseases:
      disease['probability'] = 0
  diseases = sorted(diseases, cmp=lambda x, y: cmp(y['probability'],x['probability']))
  for disease in diseases:
    print helpers.get_name_for_disease(disease['disease']), disease['probability']
  if user_session['question_count'] >= 3 and diseases[0]['probability'] > 0.8:
    resp.say("We have determined there is a high probability you have {0}".format(helpers.get_name_for_disease(diseases[0]['disease'])),**default_ops)
    resp.say("We suggest you seek medical attention as soon as possible",**default_ops)
    resp.hangup()
    redis.delete(request.values.get('CallSid'))
  elif user_session['question_count'] >= 7:
    resp.say("Sorry, we are unable to determine what you are sick with.",**default_ops)
    resp.redirect('/ems')
  else:
    resp.redirect('/diagnose')
  return str(resp)

	def DELETE(self, name):
		#params = web.input()
		#print params
		clipName = name
		redis.delete("cue:" + clipName)
		redis.save()
		cull_playlists(name)

def get_accessible_ids(token,ids=None):
    tmpSetName='tmp_%s'%str(uuid.uuid4())
    tmpSetName=getAccessibleSet(token,tmpSetName,ids=ids)
    if tmpSetName==None:
        return None
    else:
        redis=brconfig.getRedis()
        ret_ids=redis.smembers(tmpSetName)
        redis.delete(tmpSetName)
        return ret_ids

def rget(redis,key):
    str = redis.get(key)
    if str:
        try:
            object = Pickle.loads(str)
            return object
        except:
            print "fail removing" + key
            redis.delete(key)
    return False

def ems():
  print "Showing number to user"
  user_session = get_session(redis,request.values.get('CallSid'))
  number = helpers.get_phone_for_country(user_session['location'])
  print number
  resp = twilio.twiml.Response()
  resp.say("To get emergency medical attention in your country hang up and dial {0}".format(" ".join(list(str(number)))),**default_ops)
  resp.hangup()
  redis.delete(request.values.get('CallSid'))
  return str(resp)

 def remove(sid, realm):
     redis = get_redis()
     redis.delete("session-%s" % sid)
     try:
         s = Session.select().join(User).where(
             (Session.id == sid) & (User.realm == realm)).get()
         s.delete_instance()
         return True
     except Session.DoesNotExist:
         return False

    def _clear(self, pipe=None):
        """Helper for clear operations.

        :param pipe: Redis pipe in case update is performed as a part
                     of transaction.
        :type pipe: :class:`redis.client.StrictPipeline` or
                    :class:`redis.client.StrictRedis`
        """
        redis = pipe if pipe is not None else self.redis
        redis.delete(self.key)

def flush_dead_mappers(redis, mappers_key, ping_key):
    mappers = redis.smembers(mappers_key)
    for mapper in mappers:
        last_ping = redis.get(ping_key % mapper)
        if last_ping:
            now = datetime.now()
            last_ping = datetime.strptime(last_ping, DATETIME_FORMAT)
            if ((now - last_ping).seconds > TIMEOUT):
                logging.warning('MAPPER %s found to be inactive after %d seconds of not pinging back' % (mapper, TIMEOUT))
                redis.srem(mappers_key, mapper)
                redis.delete(ping_key % mapper)

def route_post_initialize():
    redis = get_redis()

    for key in redis.keys('isu4:*'):
        redis.delete(key)

    shutil.rmtree(get_dir('log'))

    response = make_response('OK')
    response.headers['Content-Type'] = 'text/plain'
    return response

def clean():
    for item in checklist:
        queued = item + ":requests"
        queued_num = redis.zcard(queued)
        if queued_num > 0:
            redis.delete(queued)
        cached = item + ":items"
        cached_num = redis.llen(cached)
        if cached_num > 0:
            redis.delete(cached)
    print("Clean all queued requests successfully!")

def hangup():
    try:
        From = request.args['From']
        CallUUID = request.args['CallUUID']

        if CallUUID == redis.get(From):
            redis.delete(From)

    except KeyError:
        pass
    
    return "Done"