Python StrictRedis.spop方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import spop [as 别名]
def main():
    logging.basicConfig(level=logging.INFO)
    r = StrictRedis()
    while True:
        logging.info("Waiting for a screenshot...")
        # block if no screenshots
        r.brpop('pending_screenshot_blocked_list')[1]
        # get a pending screenshot
        url = r.spop('pending_screenshots')

        if url:
            pipeline = r.pipeline()
            pipeline.get('pending_screenshot_{}'.format(url))
            pipeline.delete('pending_screenshot_{}'.format(url))
            filename, _ = pipeline.execute()

            logging.info("Taking screenshot of {} to {}".format(url, filename))

            screenshot_path = os.path.join('/Users/dhumbert/Code/Projects/Misc/clementia/public/user/screenshots', filename)
            subprocess.Popen(['/usr/local/bin/phantomjs', 'screenshot.js', url, screenshot_path], stderr=subprocess.STDOUT, stdout=subprocess.PIPE).communicate()

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

# redis server config
rs = StrictRedis('10.118.187.21')
rs_sname_result = 'tmall_shopinfo_temp'

title = 'name,href,addr,brnad,monthsale,productsum,dsr_desc_mark,' \
        'dsr_desc_avg,dsr_service_mark,dsr_service_avg,dsr_sending_mark,' \
        'dsr_sending_avg,sgr,srn,encryptedUserId,productDataNid_1,' \
        'product_link_1,price_1,productDataNid_2,product_link_2,price_2,' \
        'productDataNid_3,product_link_3,price_3,' \
        'productDataNid_4,product_link_4,price_4,shopDataUid'.split(',')

result = list()
n = 0
while rs.scard(rs_sname_result):
    result.append(json.loads(rs.spop(rs_sname_result)))
    n += 1
    print n
# file_path = 'd:/spider/tmall/baseInfo'
# CentOS
file_path = '/app/tmall_temp'
csv_writer = MyCsv.Write_Csv(path=file_path,
                             name='shopInfo',
                             title=title,
                             result=result
                             )
csv_writer.add_title_data()
rs.delete(rs_sname_result)

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

    def __init__(self):
        # initialize redis here
        redis_args = {
            'host': current_app.config['redis']['host'],
            'password': current_app.config['redis']['password'],
            'port': current_app.config['redis']['port']
        }
        self.redis = StrictRedis(**redis_args)

        self.keys = {
            'red': 'red:{user_id}'.format(user_id=g.user_id),
            'blue': 'blue:{user_id}'.format(user_id=g.user_id),
            'green': 'green:{user_id}'.format(user_id=g.user_id)
        }
        self.check_keys = {
            'red': 'red:{user_id}:lcase'.format(user_id=g.user_id),
            'blue': 'blue:{user_id}:lcase'.format(user_id=g.user_id),
            'green': 'green:{user_id}:lcase'.format(user_id=g.user_id)
        }

        self.todays_note_key = '{user_id}:notes:{date}'.format(
            user_id=g.user_id, date=datetime.combine(
                datetime.now(pytz.timezone('US/Pacific')).date(), time())
            .strftime('%y%m%d'))

        self.previous_notes_key = '{user_id}:notes:*'.format(
            user_id=g.user_id)

    def get_notes_count(self):
        with self.redis.pipeline() as pipe:
            pipe.scard(self.keys['red'])
            pipe.scard(self.keys['blue'])
            pipe.scard(self.keys['green'])
            results = pipe.execute()
        return {'red': results[0], 'blue': results[1], 'green': results[2]}

    def get_color(self, type):
        if type in self.keys:
            notes = self.redis.smembers(self.keys[type])
            return notes
        else:
            return []

    def add_notes(self, notes):
        with self.redis.pipeline() as pipe:
            for type, note_list in notes.iteritems():
                for note in note_list:
                    pipe.sadd(self.keys[type], note)
                    pipe.sadd(self.check_keys[type], note.lower())
            pipe.execute()

    def validate_notes(self, notes):
        checked_notes = []
        with self.redis.pipeline() as pipe:
            for type, note_list in notes.iteritems():
                for note in note_list:
                    if type in self.keys:
                        checked_notes.append(note)
                        pipe.sismember(self.check_keys[type], note.lower())
                    else:
                        raise HTTPError(403, 'invalid note type')
            results = pipe.execute()
        err_notes = []
        for i, result in enumerate(results):
            if result == 1:
                err_notes.append(checked_notes[i])
        if err_notes:
            err_message = "Some notes already exist."
            raise HTTPError(403, {'message': err_message, 'notes': err_notes})

    def modify_note(self, type, old_note, new_note):
        if type in self.keys:
            if not self.redis.sismember(self.keys[type], new_note):
                self.delete_note(type, old_note)
                self.add_note(type, new_note)
            else:
                return {'result': 'error', 'err': 'message already in key'}
        else:
            raise HTTPError(403, 'invalid note type')

    def delete_note(self, type, note):
        if type in self.keys:
            self.redis.srem(self.keys[type], note)
            self.redis.srem(self.check_keys[type], note.lower())
            return {'result': 'success'}
        else:
            raise HTTPError(403, 'invalid note type')

    def get_todays_note(self, type=None):
        if not self.redis.exists(self.todays_note_key):
            if not type:
                return None
            note = self.redis.spop(self.keys[type])
            if note:
                note_value = {
                    'note': note,
                    'type': type
                }
#.........这里部分代码省略.........